ctdb/lib/util/util_file.c

   1 /*
   2   functions taken from samba4 for quick prototyping of ctdb. These are
   3   not intended to remain part of ctdb
   4 */
   5
   6 #include <assert.h>
   7
   8 #include "includes.h"
   9 #include "system/filesys.h"
  10
  11
  12 static char *fd_load(int fd, size_t *size, TALLOC_CTX *mem_ctx)
  13 {
  14         struct stat sbuf;
  15         char *p;
  16
  17         if (fstat(fd, &sbuf) != 0) return NULL;
  18
  19         p = (char *)talloc_size(mem_ctx, sbuf.st_size+1);
  20         if (!p) return NULL;
  21
  22         if (read(fd, p, sbuf.st_size) != sbuf.st_size) {
  23                 talloc_free(p);
  24                 return NULL;
  25         }
  26         p[sbuf.st_size] = 0;
  27
  28         if (size) *size = sbuf.st_size;
  29
  30         return p;
  31 }
  32
  33
  34 static char *file_load(const char *fname, size_t *size, TALLOC_CTX *mem_ctx)
  35 {
  36         int fd;
  37         char *p;
  38
  39         if (!fname || !*fname) return NULL;
  40
  41         fd = open(fname,O_RDONLY);
  42         if (fd == -1) return NULL;
  43
  44         p = fd_load(fd, size, mem_ctx);
  45
  46         close(fd);
  47
  48         return p;
  49 }
  50
  51
  52 /**
  53 parse a buffer into lines
  54 'p' will be freed on error, and otherwise will be made a child of the returned array
  55 **/
  56 static char **file_lines_parse(char *p, size_t size, int *numlines, TALLOC_CTX *mem_ctx)
  57 {
  58         int i;
  59         char *s, **ret;
  60
  61         if (!p) return NULL;
  62
  63         for (s = p, i=0; s < p+size; s++) {
  64                 if (s[0] == '\n') i++;
  65         }
  66
  67         ret = talloc_array(mem_ctx, char *, i+2);
  68         if (!ret) {
  69                 talloc_free(p);
  70                 return NULL;
  71         }
  72
  73         talloc_steal(ret, p);
  74
  75         memset(ret, 0, sizeof(ret[0])*(i+2));
  76         if (numlines) *numlines = i;
  77
  78         ret[0] = p;
  79         for (s = p, i=0; s < p+size; s++) {
  80                 if (s[0] == '\n') {
  81                         s[0] = 0;
  82                         i++;
  83                         ret[i] = s+1;
  84                 }
  85                 if (s[0] == '\r') s[0] = 0;
  86         }
  87
  88         return ret;
  89 }
  90
  91
  92 /**
  93 load a file into memory and return an array of pointers to lines in the file
  94 must be freed with talloc_free().
  95 **/
  96 _PUBLIC_ char **file_lines_load(const char *fname, int *numlines, size_t maxsize, TALLOC_CTX *mem_ctx)
  97 {
  98         char *p;
  99         size_t size;
 100
 101         assert(maxsize == 0);
 102
 103         p = file_load(fname, &size, mem_ctx);
 104         if (!p) return NULL;
 105
 106         return file_lines_parse(p, size, numlines, mem_ctx);
 107 }
 108
 109 char *hex_encode_talloc(TALLOC_CTX *mem_ctx, const unsigned char *buff_in, size_t len)
 110 {
 111         int i;
 112         char *hex_buffer;
 113
 114         hex_buffer = talloc_array(mem_ctx, char, (len*2)+1);
 115
 116         for (i = 0; i < len; i++)
 117                 slprintf(&hex_buffer[i*2], 3, "%02X", buff_in[i]);
 118
 119         return hex_buffer;
 120 }