source/lib/util_file.c

   1 /*
   2  * Unix SMB/Netbios implementation. Version 1.9. SMB parameters and setup
   3  * Copyright (C) Andrew Tridgell 1992-1998 Modified by Jeremy Allison 1995.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it under
   6  * the terms of the GNU General Public License as published by the Free
   7  * Software Foundation; either version 2 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * this program; if not, write to the Free Software Foundation, Inc., 675
  17  * Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19
  20 #include "includes.h"
  21
  22 static int gotalarm;
  23
  24 /***************************************************************
  25  Signal function to tell us we timed out.
  26 ****************************************************************/
  27
  28 static void gotalarm_sig(void)
  29 {
  30   gotalarm = 1;
  31 }
  32
  33 /***************************************************************
  34  Lock or unlock a fd for a known lock type. Abandon after waitsecs
  35  seconds.
  36 ****************************************************************/
  37
  38 BOOL do_file_lock(int fd, int waitsecs, int type)
  39 {
  40   SMB_STRUCT_FLOCK lock;
  41   int             ret;
  42
  43   gotalarm = 0;
  44   CatchSignal(SIGALRM, SIGNAL_CAST gotalarm_sig);
  45
  46   lock.l_type = type;
  47   lock.l_whence = SEEK_SET;
  48   lock.l_start = 0;
  49   lock.l_len = 1;
  50   lock.l_pid = 0;
  51
  52   alarm(waitsecs);
  53   /* Note we must *NOT* use sys_fcntl here ! JRA */
  54   ret = fcntl(fd, SMB_F_SETLKW, &lock);
  55   alarm(0);
  56   CatchSignal(SIGALRM, SIGNAL_CAST SIG_IGN);
  57
  58   if (gotalarm) {
  59     DEBUG(0, ("do_file_lock: failed to %s file.\n",
  60                 type == F_UNLCK ? "unlock" : "lock"));
  61     return False;
  62   }
  63
  64   return (ret == 0);
  65 }
  66
  67
  68 /***************************************************************
  69  Lock an fd. Abandon after waitsecs seconds.
  70 ****************************************************************/
  71
  72 BOOL file_lock(int fd, int type, int secs, int *plock_depth)
  73 {
  74   if (fd < 0)
  75     return False;
  76
  77   (*plock_depth)++;
  78
  79   if ((*plock_depth) == 0)
  80   {
  81     if (!do_file_lock(fd, secs, type)) {
  82       DEBUG(10,("file_lock: locking file failed, error = %s.\n",
  83                  strerror(errno)));
  84       return False;
  85     }
  86   }
  87
  88   return True;
  89 }
  90
  91 /***************************************************************
  92  Unlock an fd. Abandon after waitsecs seconds.
  93 ****************************************************************/
  94
  95 BOOL file_unlock(int fd, int *plock_depth)
  96 {
  97   BOOL ret=True;
  98
  99   if(*plock_depth == 1)
 100     ret = do_file_lock(fd, 5, F_UNLCK);
 101
 102   (*plock_depth)--;
 103
 104   if(!ret)
 105     DEBUG(10,("file_unlock: unlocking file failed, error = %s.\n",
 106                  strerror(errno)));
 107   return ret;
 108 }
 109
 110 /***************************************************************
 111  locks a file for enumeration / modification.
 112  update to be set = True if modification is required.
 113 ****************************************************************/
 114
 115 void *startfilepwent(char *pfile, char *s_readbuf, int bufsize,
 116                                 int *file_lock_depth, BOOL update)
 117 {
 118   FILE *fp = NULL;
 119
 120   if (!*pfile)
 121  {
 122     DEBUG(0, ("startfilepwent: No file set\n"));
 123     return (NULL);
 124   }
 125   DEBUG(10, ("startfilepwent: opening file %s\n", pfile));
 126
 127   fp = sys_fopen(pfile, update ? "r+b" : "rb");
 128
 129   if (fp == NULL) {
 130     DEBUG(0, ("startfilepwent: unable to open file %s\n", pfile));
 131     return NULL;
 132   }
 133
 134   /* Set a buffer to do more efficient reads */
 135   setvbuf(fp, s_readbuf, _IOFBF, bufsize);
 136
 137   if (!file_lock(fileno(fp), (update ? F_WRLCK : F_RDLCK), 5, file_lock_depth))
 138   {
 139     DEBUG(0, ("startfilepwent: unable to lock file %s\n", pfile));
 140     fclose(fp);
 141     return NULL;
 142   }
 143
 144   /* Make sure it is only rw by the owner */
 145   chmod(pfile, 0600);
 146
 147   /* We have a lock on the file. */
 148   return (void *)fp;
 149 }
 150
 151 /***************************************************************
 152  End enumeration of the file.
 153 ****************************************************************/
 154 void endfilepwent(void *vp, int *file_lock_depth)
 155 {
 156   FILE *fp = (FILE *)vp;
 157
 158   file_unlock(fileno(fp), file_lock_depth);
 159   fclose(fp);
 160   DEBUG(7, ("endfilepwent: closed file.\n"));
 161 }
 162
 163 /*************************************************************************
 164  Return the current position in the file list as an SMB_BIG_UINT.
 165  This must be treated as an opaque token.
 166 *************************************************************************/
 167 SMB_BIG_UINT getfilepwpos(void *vp)
 168 {
 169   return (SMB_BIG_UINT)sys_ftell((FILE *)vp);
 170 }
 171
 172 /*************************************************************************
 173  Set the current position in the file list from an SMB_BIG_UINT.
 174  This must be treated as an opaque token.
 175 *************************************************************************/
 176 BOOL setfilepwpos(void *vp, SMB_BIG_UINT tok)
 177 {
 178   return !sys_fseek((FILE *)vp, (SMB_OFF_T)tok, SEEK_SET);
 179 }
 180
 181 /*************************************************************************
 182  gets a line out of a file.
 183  line is of format "xxxx:xxxxxx:xxxxx:".
 184  lines with "#" at the front are ignored.
 185 *************************************************************************/
 186 int getfileline(void *vp, char *linebuf, int linebuf_size)
 187 {
 188         /* Static buffers we will return. */
 189         FILE *fp = (FILE *)vp;
 190         unsigned char   c;
 191         unsigned char  *p;
 192         size_t            linebuf_len;
 193
 194         if (fp == NULL)
 195         {
 196                 DEBUG(0,("getfileline: Bad file pointer.\n"));
 197                 return -1;
 198         }
 199
 200         /*
 201          * Scan the file, a line at a time.
 202          */
 203         while (!feof(fp))
 204         {
 205                 linebuf[0] = '\0';
 206
 207                 fgets(linebuf, linebuf_size, fp);
 208                 if (ferror(fp))
 209                 {
 210                         return -1;
 211                 }
 212
 213                 /*
 214                  * Check if the string is terminated with a newline - if not
 215                  * then we must keep reading and discard until we get one.
 216                  */
 217
 218                 linebuf_len = strlen(linebuf);
 219                 if (linebuf_len == 0)
 220                 {
 221                         linebuf[0] = '\0';
 222                         return 0;
 223                 }
 224
 225                 if (linebuf[linebuf_len - 1] != '\n')
 226                 {
 227                         c = '\0';
 228                         while (!ferror(fp) && !feof(fp))
 229                         {
 230                                 c = fgetc(fp);
 231                                 if (c == '\n')
 232                                 {
 233                                         break;
 234                                 }
 235                         }
 236                 }
 237                 else
 238                 {
 239                         linebuf[linebuf_len - 1] = '\0';
 240                 }
 241
 242 #ifdef DEBUG_PASSWORD
 243                 DEBUG(100, ("getfileline: got line |%s|\n", linebuf));
 244 #endif
 245                 if ((linebuf[0] == 0) && feof(fp))
 246                 {
 247                         DEBUG(4, ("getfileline: end of file reached\n"));
 248                         return 0;
 249                 }
 250
 251                 if (linebuf[0] == '#' || linebuf[0] == '\0')
 252                 {
 253                         DEBUG(6, ("getfileline: skipping comment or blank line\n"));
 254                         continue;
 255                 }
 256
 257                 p = (unsigned char *) strchr(linebuf, ':');
 258                 if (p == NULL)
 259                 {
 260                         DEBUG(0, ("getfileline: malformed line entry (no :)\n"));
 261                         continue;
 262                 }
 263                 return linebuf_len;
 264         }
 265         return -1;
 266 }
 267
 268
 269 /****************************************************************************
 270 read a line from a file with possible \ continuation chars.
 271 Blanks at the start or end of a line are stripped.
 272 The string will be allocated if s2 is NULL
 273 ****************************************************************************/
 274 char *fgets_slash(char *s2,int maxlen,FILE *f)
 275 {
 276   char *s=s2;
 277   int len = 0;
 278   int c;
 279   BOOL start_of_line = True;
 280
 281   if (feof(f))
 282     return(NULL);
 283
 284   if (maxlen <2) return(NULL);
 285
 286   if (!s2)
 287     {
 288       char *t;
 289
 290       maxlen = MIN(maxlen,8);
 291       t = (char *)Realloc(s,maxlen);
 292       if (!t) {
 293         DEBUG(0,("fgets_slash: failed to expand buffer!\n"));
 294         SAFE_FREE(s);
 295         return(NULL);
 296       } else
 297         s = t;
 298     }
 299
 300   if (!s)
 301     return(NULL);
 302
 303   *s = 0;
 304
 305   while (len < maxlen-1)
 306     {
 307       c = getc(f);
 308       switch (c)
 309         {
 310         case '\r':
 311           break;
 312         case '\n':
 313           while (len > 0 && s[len-1] == ' ')
 314             {
 315               s[--len] = 0;
 316             }
 317           if (len > 0 && s[len-1] == '\\')
 318             {
 319               s[--len] = 0;
 320               start_of_line = True;
 321               break;
 322             }
 323           return(s);
 324         case EOF:
 325           if (len <= 0 && !s2)
 326             SAFE_FREE(s);
 327           return(len>0?s:NULL);
 328         case ' ':
 329           if (start_of_line)
 330             break;
 331         default:
 332           start_of_line = False;
 333           s[len++] = c;
 334           s[len] = 0;
 335         }
 336       if (!s2 && len > maxlen-3) {
 337         char *t;
 338
 339         maxlen *= 2;
 340         t = (char *)Realloc(s,maxlen);
 341         if (!t) {
 342           DEBUG(0,("fgets_slash: failed to expand buffer!\n"));
 343           SAFE_FREE(s);
 344           return(NULL);
 345         } else
 346           s = t;
 347       }
 348     }
 349   return(s);
 350 }
 351
 352
 353 /****************************************************************************
 354 load from a pipe into memory
 355 ****************************************************************************/
 356 char *file_pload(const char *syscmd, size_t *size)
 357 {
 358         int fd, n;
 359         char *p, *tp;
 360         pstring buf;
 361         size_t total;
 362
 363         fd = sys_popen(syscmd);
 364         if (fd == -1) return NULL;
 365
 366         p = NULL;
 367         total = 0;
 368
 369         while ((n = read(fd, buf, sizeof(buf))) > 0) {
 370                 tp = Realloc(p, total + n + 1);
 371                 if (!tp) {
 372                         DEBUG(0,("file_pload: failed to exand buffer!\n"));
 373                         close(fd);
 374                         SAFE_FREE(p);
 375                         return NULL;
 376                 } else
 377                         p = tp;
 378                 memcpy(p+total, buf, n);
 379                 total += n;
 380         }
 381         if (p) p[total] = 0;
 382
 383         sys_pclose(fd);
 384
 385         if (size) *size = total;
 386
 387         return p;
 388 }
 389
 390 /****************************************************************************
 391 load a file into memory from a fd.
 392 ****************************************************************************/
 393
 394 char *fd_load(int fd, size_t *size)
 395 {
 396         SMB_STRUCT_STAT sbuf;
 397         char *p;
 398
 399         if (sys_fstat(fd, &sbuf) != 0) return NULL;
 400
 401         p = (char *)malloc(sbuf.st_size+1);
 402         if (!p) return NULL;
 403
 404         if (read(fd, p, sbuf.st_size) != sbuf.st_size) {
 405                 SAFE_FREE(p);
 406                 return NULL;
 407         }
 408         p[sbuf.st_size] = 0;
 409
 410         if (size) *size = sbuf.st_size;
 411
 412         return p;
 413 }
 414
 415 /****************************************************************************
 416 load a file into memory
 417 ****************************************************************************/
 418 char *file_load(const char *fname, size_t *size)
 419 {
 420         int fd;
 421         char *p;
 422
 423         if (!fname || !*fname) return NULL;
 424
 425         fd = open(fname,O_RDONLY);
 426         if (fd == -1) return NULL;
 427
 428         p = fd_load(fd, size);
 429
 430         close(fd);
 431
 432         return p;
 433 }
 434
 435
 436 /****************************************************************************
 437 parse a buffer into lines
 438 ****************************************************************************/
 439 static char **file_lines_parse(char *p, size_t size, int *numlines, BOOL convert)
 440 {
 441         int i;
 442         char *s, **ret;
 443
 444         if (!p) return NULL;
 445
 446         for (s = p, i=0; s < p+size; s++) {
 447                 if (s[0] == '\n') i++;
 448         }
 449
 450         ret = (char **)malloc(sizeof(ret[0])*(i+2));
 451         if (!ret) {
 452                 SAFE_FREE(p);
 453                 return NULL;
 454         }
 455         memset(ret, 0, sizeof(ret[0])*(i+2));
 456         if (numlines) *numlines = i;
 457
 458         ret[0] = p;
 459         for (s = p, i=0; s < p+size; s++) {
 460                 if (s[0] == '\n') {
 461                         s[0] = 0;
 462                         i++;
 463                         ret[i] = s+1;
 464                 }
 465                 if (s[0] == '\r') s[0] = 0;
 466         }
 467
 468         if (convert) {
 469                 for (i = 0; ret[i]; i++)
 470                         unix_to_dos(ret[i]);
 471         }
 472
 473         return ret;
 474 }
 475
 476
 477 /****************************************************************************
 478 load a file into memory and return an array of pointers to lines in the file
 479 must be freed with file_lines_free(). If convert is true calls unix_to_dos on
 480 the list.
 481 ****************************************************************************/
 482 char **file_lines_load(const char *fname, int *numlines, BOOL convert)
 483 {
 484         char *p;
 485         size_t size;
 486
 487         p = file_load(fname, &size);
 488         if (!p) return NULL;
 489
 490         return file_lines_parse(p, size, numlines, convert);
 491 }
 492
 493 /****************************************************************************
 494 load a fd into memory and return an array of pointers to lines in the file
 495 must be freed with file_lines_free(). If convert is true calls unix_to_dos on
 496 the list.
 497 ****************************************************************************/
 498 char **fd_lines_load(int fd, int *numlines, BOOL convert)
 499 {
 500         char *p;
 501         size_t size;
 502
 503         p = fd_load(fd, &size);
 504         if (!p) return NULL;
 505
 506         return file_lines_parse(p, size, numlines, convert);
 507 }
 508
 509
 510 /****************************************************************************
 511 load a pipe into memory and return an array of pointers to lines in the data
 512 must be freed with file_lines_free(). If convert is true calls unix_to_dos on
 513 the list.
 514 ****************************************************************************/
 515 char **file_lines_pload(const char *syscmd, int *numlines, BOOL convert)
 516 {
 517         char *p;
 518         size_t size;
 519
 520         p = file_pload(syscmd, &size);
 521         if (!p) return NULL;
 522
 523         return file_lines_parse(p, size, numlines, convert);
 524 }
 525
 526 /****************************************************************************
 527 free lines loaded with file_lines_load
 528 ****************************************************************************/
 529 void file_lines_free(char **lines)
 530 {
 531         if (!lines) return;
 532         SAFE_FREE(lines[0]);
 533         SAFE_FREE(lines);
 534 }
 535
 536
 537 /****************************************************************************
 538 take a lislist of lines and modify them to produce a list where \ continues
 539 a line
 540 ****************************************************************************/
 541 void file_lines_slashcont(char **lines)
 542 {
 543         int i, j;
 544
 545         for (i=0; lines[i];) {
 546                 int len = strlen(lines[i]);
 547                 if (lines[i][len-1] == '\\') {
 548                         lines[i][len-1] = ' ';
 549                         if (lines[i+1]) {
 550                                 char *p = &lines[i][len];
 551                                 while (p < lines[i+1]) *p++ = ' ';
 552                                 for (j = i+1; lines[j]; j++) lines[j] = lines[j+1];
 553                         }
 554                 } else {
 555                         i++;
 556                 }
 557         }
 558 }