users.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <ctype.h>
   5 #include <sys/stat.h>
   6 #include <unistd.h>
   7 #include "log.h"
   8 #include "users.h"
   9
  10 #define USERS_FILE "./users"
  11
  12
  13 static int check_user_name (const char *name)
  14 {
  15         int i;
  16
  17
  18         if (!isalpha(name[0])) return 0;
  19
  20         for (i = 1; name[i] != 0; i++)
  21         {
  22                 if (!isalnum(name[i])) return 0;
  23         }
  24
  25         // minimal length
  26         return i >= 3;
  27 }
  28
  29
  30
  31 /*
  32  * str must be 0-terminated
  33  * NB! content of str will be destroyed in the process
  34  */
  35 static int parse_user (user *usr, char *str)
  36 {
  37         char *s;
  38         if ((s = strstr(str, ":")) == NULL) return 0;
  39         *s = 0;
  40
  41         // id
  42         usr->id = atoi(str);
  43
  44         str = s + 1;
  45         if ((s = strstr(str, ":")) == NULL) return 0;
  46         *s = 0;
  47
  48         // name
  49         strncpy (usr->name, str, USER_NAME_LEN);
  50         usr->name[USER_NAME_LEN - 1] = 0;
  51
  52         str = s + 1;
  53         if ((s = strstr(str, ":")) == NULL) return 0;
  54         *s = 0;
  55
  56         // password
  57         strncpy (usr->pass, str, USER_PASS_LEN);
  58         usr->name[USER_PASS_LEN - 1] = 0;
  59
  60         str = s + 1;
  61         if ((s = strstr(str, "\n")) != NULL) *s = 0;    // remove optional \n at the end
  62
  63         // email
  64         strncpy (usr->email, str, USER_EMAIL_LEN);
  65         usr->name[USER_EMAIL_LEN - 1] = 0;
  66
  67         return 1;
  68 }
  69
  70
  71
  72 #define BUF_SZ  1024
  73
  74 /*
  75  * if user is not found usr will be filled with garbage
  76  *      and also if max_id is not NULL, it will contain max encountered user id
  77  */
  78 static int find_user (const char *name, user *usr, FILE *f, int *max_id)
  79 {
  80         int m = 0;
  81
  82         while (1)
  83         {
  84                 char buf[BUF_SZ];
  85
  86                 // end of file
  87                 if (fgets(buf, BUF_SZ, f) == NULL) break;
  88
  89                 // skip comments and empty lines
  90                 if (buf[0] == '#' || buf[0] == 0) continue;
  91
  92                 if (!parse_user(usr, buf))
  93                 {
  94                         continue;
  95                 }
  96
  97                 // logins are case-insensitive
  98                 if (strcasecmp(name, usr->name) == 0) return usr->id;
  99
 100                 // update max id
 101                 if (usr->id > m) m = usr->id;
 102         }
 103
 104         if (max_id != NULL) *max_id = m;
 105         return 0;
 106 }
 107
 108
 109
 110 static void write_user (FILE *f, const user *usr)
 111 {
 112         fprintf (f, "%d:%s:%s:%s\n", usr->id, usr->name, usr->pass, usr->email);
 113 }
 114
 115
 116
 117 int add_user (user *usr, const char *name, const char *pass, const char *email)
 118 {
 119         int id;
 120         FILE *f;
 121
 122         if (!check_user_name(name)) return -1;
 123
 124         if ((f = fopen(USERS_FILE, "r+")) == NULL)
 125         {
 126                 write_log (LOG_ERROR, "error opening " USERS_FILE);
 127                 return -2;
 128         }
 129
 130         // lock file to block access from other threads
 131         if (lockf(fileno(f), F_LOCK, 0) != 0)
 132         {
 133                 write_log (LOG_ERROR, "error locking " USERS_FILE);
 134                 fclose (f);
 135                 return -3;
 136         }
 137
 138         // user already exists
 139         if (find_user(name, usr, f, &id))
 140         {
 141                 fclose (f);
 142                 return -4;
 143         }
 144
 145         id++;
 146         usr->id = id;
 147
 148         strncpy (usr->name, name, USER_NAME_LEN);
 149         usr->name[USER_NAME_LEN - 1] = 0;
 150
 151         strncpy (usr->pass, pass, USER_PASS_LEN);
 152         usr->pass[USER_PASS_LEN - 1] = 0;
 153
 154         strncpy (usr->email, email, USER_EMAIL_LEN);
 155         usr->email[USER_EMAIL_LEN - 1] = 0;
 156
 157         // add user record to the file
 158         fseek (f, 0, SEEK_END);
 159
 160         write_user (f, usr);
 161
 162         fclose (f);
 163
 164         return id;
 165 }
 166
 167
 168
 169 int check_user_login (user *usr, const char *name, const char *pass)
 170 {
 171         int id;
 172         FILE *f;
 173
 174
 175         f = fopen(USERS_FILE, "r+");    // r+ is needed for locking
 176         if (f == NULL)
 177         {
 178                 write_log (LOG_ERROR, "error opening " USERS_FILE);
 179                 return -2;
 180         }
 181
 182         // lock file to block access from other threads
 183         if (lockf(fileno(f), F_LOCK, 0) != 0)
 184         {
 185                 write_log (LOG_ERROR, "error locking " USERS_FILE);
 186                 fclose (f);
 187                 return -3;
 188         }
 189
 190         id = find_user(name, usr, f, NULL);
 191         fclose (f);
 192
 193         if (id <= 0) return -4;
 194
 195         if (strcmp(pass, usr->pass) != 0) return -5;
 196
 197         return id;
 198 }
 199
 200
 201
 202 static void change_password_save (FILE *f, char *buf, int size, int user_id, const char *pass)
 203 {
 204         char str[BUF_SZ];
 205         char *end = buf + size;
 206
 207
 208         while (buf <= end)
 209         {
 210                 user usr;
 211                 char *s = strstr(buf, "\n");
 212
 213                 if (s == NULL) s = end;
 214                 else *s = 0;
 215
 216                 // copy string (parse_user is destructive)
 217                 snprintf (str, BUF_SZ, buf);
 218
 219                 // not user or not this user
 220                 // just copy the string
 221                 if (!parse_user(&usr, str) || usr.id != user_id)
 222                 {
 223                         fprintf (f, "%s\n", buf);
 224                 }
 225                 // replace password and save user
 226                 else
 227                 {
 228                         strncpy (usr.pass, pass, USER_PASS_LEN);
 229                         usr.pass[USER_PASS_LEN - 1] = 0;
 230                         write_user (f, &usr);
 231                 }
 232
 233                 buf = s + 1;
 234         }
 235 }
 236
 237
 238
 239 int change_password (int user_id, const char *pass)
 240 {
 241         struct stat st;
 242         char *buf;
 243         FILE *f;
 244
 245
 246         if ((f = fopen(USERS_FILE, "r+")) == NULL)
 247         {
 248                 write_log (LOG_ERROR, "error opening " USERS_FILE);
 249                 return -2;
 250         }
 251
 252         // lock file to block access from other threads
 253         if (lockf(fileno(f), F_LOCK, 0) != 0)
 254         {
 255                 write_log (LOG_ERROR, "error locking " USERS_FILE);
 256                 fclose (f);
 257                 return -3;
 258         }
 259
 260         // allocate buffer to store all users
 261
 262         if (fstat(fileno(f), &st) == -1)
 263         {
 264                 write_log (LOG_ERROR, "can't stat " USERS_FILE);
 265                 fclose (f);
 266                 return -4;
 267         }
 268
 269         buf = (char*)malloc(st.st_size);
 270         if (buf == NULL)
 271         {
 272                 write_log (LOG_ERROR, "unable to allocate memory to load " USERS_FILE);
 273                 fclose (f);
 274                 return -5;
 275         }
 276
 277         // read the whole user file into memory
 278         fread (buf, st.st_size, 1, f);
 279
 280         fseek (f, 0, SEEK_SET);
 281         change_password_save (f, buf, st.st_size, user_id, pass);
 282
 283         fclose (f);
 284         free (buf);
 285
 286         return 0;
 287 }
 288