silentbob/silentbob-1.4/gclib/gclib_c/gcio.c

   1 /*
   2  * (c) Oleg Puchinin 2006
   3  * graycardinalster@gmail.com
   4  *
   5  */
   6
   7 #include <gclib_c.h>
   8 #include <fcntl.h>
   9 #include <sys/mman.h>
  10 #include <sys/stat.h>
  11 #include <sys/ioctl.h>
  12 #include <stdarg.h>
  13
  14 #define __export
  15
  16 struct stat *cur_stat = NULL;
  17
  18 __export int Dfnwrite (char * p_lpsz_filename, void * p_lp_buffer,int int_size)
  19 {
  20         int result;
  21         FILE * myfile;
  22         myfile = fopen(p_lpsz_filename,"w");
  23         if(!myfile)
  24                 return 0;
  25         result = fwrite(p_lp_buffer,1,int_size,myfile);
  26         fclose(myfile);
  27         return result;
  28 }
  29
  30 __export int Dfnread (char * f_name, void * p_lp_buffer, int int_size)
  31 {
  32         int n_bytes = int_size > fsize (f_name) ? fsize (f_name) : int_size;
  33         int fd;
  34
  35         fd = open (f_name, O_RDONLY);
  36         if (fd < 0)
  37                 return fd;
  38
  39         if (read (fd, p_lp_buffer, n_bytes) < 0)
  40                 n_bytes = -1;
  41
  42         close (fd);
  43         return n_bytes;
  44 }
  45
  46 __export int Dselect (int FILENO, int SEC, int USEC)
  47 {
  48         struct timeval m_timeval;
  49         fd_set m_fdset;
  50
  51         FD_ZERO (&m_fdset);
  52         FD_SET (FILENO, &m_fdset);
  53         m_timeval.tv_sec = SEC;
  54         m_timeval.tv_usec = USEC;
  55
  56         if (!m_timeval.tv_sec && !m_timeval.tv_usec)
  57                 return select (FILENO+1, &m_fdset, NULL, NULL, NULL);// &m_timeval);
  58         else
  59                 return select (FILENO+1, &m_fdset, NULL, NULL, &m_timeval);
  60 }
  61
  62 __export char * DFILE (const char * m_filename, int *rsize)
  63 {
  64         char * m_file;
  65         struct stat m_stat;
  66         char * ptr;
  67         int count;
  68         int len;
  69         int fd;
  70
  71         if (m_filename == NULL)
  72                 return NULL;
  73
  74         fd = open (m_filename, O_RDONLY);
  75         if (fd < 0)
  76                 return NULL;
  77
  78         if (lstat (m_filename, &m_stat) < 0)
  79                 return NULL;
  80
  81         m_file = malloc (m_stat.st_size);
  82         if (m_file == NULL)
  83                 return NULL;
  84
  85         ptr = m_file;
  86         len = m_stat.st_size;
  87         while (-1) {
  88                 count = read (fd, ptr, len);
  89                 if (count <= 0)
  90                         break;
  91                 ptr+=count;
  92                 len-=count;
  93         }
  94
  95         if (rsize)
  96                 *rsize = m_stat.st_size;
  97
  98         close (fd);
  99         return m_file;
 100 }
 101
 102 __export struct stat * DSTAT (const char * S)
 103 {
 104         if (!cur_stat)
 105                 cur_stat = malloc (sizeof (struct stat));
 106         stat (S, cur_stat);
 107         return cur_stat;
 108 }
 109
 110 __export struct stat * DLSTAT (const char * S)
 111 {
 112         if (! cur_stat)
 113                 cur_stat = malloc (sizeof (struct stat));
 114         lstat (S, cur_stat);
 115         return cur_stat;
 116 }
 117
 118 __export int DIONREAD (int fd)
 119 {
 120         int ret = -1;
 121
 122         if (ioctl (fd, FIONREAD, &ret) != 0)
 123                 return -1;
 124
 125         return ret;
 126 }
 127
 128 __export int fsize (const char * S)
 129 {
 130         struct stat m_stat;
 131
 132         if (lstat (S, &m_stat) < 0)
 133                 return -1;
 134
 135         return m_stat.st_size;
 136 }
 137
 138 __export int fdsize (int fd)
 139 {
 140         struct stat m_stat;
 141
 142         if (fstat (fd, &m_stat) < 0)
 143                 return -1;
 144
 145         return m_stat.st_size;
 146 }
 147
 148 __export char * DFDMAP (int fd)
 149 {
 150         return (char *) mmap (NULL, fdsize (fd), PROT_READ, MAP_SHARED, fd, 0);
 151 }
 152
 153 __export char * DFMAP (const char *d_file, int *out_fd, int *d_out_size)
 154 {
 155         char *S = NULL;
 156         int d_size;
 157         int fd;
 158
 159         fd = open (d_file, O_RDONLY);
 160         if (fd < 0)
 161                 return NULL;
 162
 163         d_size = fdsize (fd);
 164
 165         if (d_out_size)
 166                 *d_out_size = d_size;
 167
 168         if (out_fd)
 169                 *out_fd = fd;
 170
 171         S = (char *) mmap (NULL, d_size, PROT_READ, MAP_SHARED, fd, 0);
 172
 173         if ((long) S == -1) {
 174                 close (fd);
 175                 return NULL;
 176         }
 177
 178         return S;
 179 }
 180
 181 __export char * Dread_to_eof (int fd, int *d_out_size)
 182 {
 183         char * d_buf = (char *) malloc (4096);
 184         int d_size = 4096;
 185         int d_pos = 0;
 186         int d_ret = 0;
 187
 188         if (fd < 0)
 189                 return NULL;
 190
 191         if (d_out_size)
 192                 *d_out_size = 0;
 193
 194         while (-1) {
 195                 d_ret = read (fd, &d_buf[d_pos], d_size - d_pos - 1);
 196                 if (d_ret == -1)
 197                         return NULL;
 198
 199                 if (d_ret == 0) //EOF
 200                         break;
 201
 202                 d_pos += d_ret;
 203                 if ((d_size - d_pos) < 4096) {
 204                         d_buf = gc_realloc (d_buf, d_size, d_size << 1);
 205                         d_size<<=1;
 206                         if (d_buf == NULL) {
 207                                 if (d_out_size)
 208                                         *d_out_size = 0;
 209                                 return NULL;
 210                         }
 211                 }
 212         }
 213
 214         if (d_out_size)
 215                 *d_out_size = d_pos;
 216
 217         d_buf[d_pos] = 0;
 218         return d_buf;
 219 }
 220
 221 __export int move_stream (int fd_in, int fd_out)
 222 {
 223         char * m_buf = NULL;
 224         int i;
 225         int Ret = 0;
 226
 227         m_buf = malloc (4096);
 228
 229         while (-1) {
 230                 i = read (fd_in, m_buf, 4096);
 231                 if (i <= 0)
 232                         break;
 233                 Ret += i;
 234                 write (fd_out, m_buf, i);
 235         }
 236
 237         free (m_buf);
 238         return Ret;
 239 }
 240
 241 __export int Dnonblock(int fd)
 242 {
 243         int flags = fcntl(fd, F_GETFL);
 244         return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
 245 }
 246
 247 __export int close_pipe (int *fds)
 248 {
 249         int Ret1 = 0;
 250         int Ret2 = 0;
 251
 252         if (fds[0] != -1) {
 253                 Ret1 = close (fds[0]);
 254                 fds[0] = -1;
 255         }
 256
 257         if (fds[1] != -1) {
 258                 Ret2 = close (fds[1]);
 259                 fds[1] = -1;
 260         }
 261
 262         return Ret1 ? Ret1 : Ret2;
 263 }
 264
 265 __export int Dtmpfd (char *name)
 266 {
 267         char m_buf[128];
 268         char tmpstr[64];
 269         int fd;
 270
 271         Drand_str (tmpstr, 63);
 272         sprintf (m_buf, "/tmp/%s", tmpstr);
 273         fd = open (m_buf, O_CREAT | O_RDWR);
 274         if (name) {
 275                 if (fd >= 0)
 276                         strcpy (name, m_buf);
 277                 else
 278                         name[0] = '\0';
 279         }
 280
 281         return fd;
 282 }
 283
 284 __export int fdclose (int * fd)
 285 {
 286         if (! fd)
 287                 return 0;
 288
 289         if (*fd != -1) {
 290                 close (*fd);
 291                 *fd = -1;
 292         }
 293         return 0;
 294 }
 295
 296 __export char * fext (char *name)
 297 {
 298         if (! name)
 299                 return NULL;
 300         return rindex (name, '.');
 301 }
 302
 303 __export int logToFile (char * fileName, char * fmt, ...)
 304 {
 305         va_list alist;
 306         FILE * myfile;
 307         myfile = fopen (fileName, "a");
 308         if (! myfile)
 309                 return -1;
 310
 311         va_start (alist, fmt);
 312         vfprintf (myfile, fmt, alist);
 313         va_end (alist);
 314         fclose (myfile);
 315         return 0;
 316 }
 317
 318 __export int copyFile (char * sourceName, char * destName)
 319 {
 320         int sourceFD = -1;;
 321         int destFD = -1;
 322         struct stat st;
 323         char * copyBuf = NULL;
 324         int ret;
 325         int count = 0;
 326
 327         if (! sourceName || ! destName)
 328                 return -1;
 329
 330         sourceFD = open (sourceName, O_RDONLY);
 331         fstat (sourceFD, &st);
 332         destFD = open (destName, O_WRONLY | O_CREAT, st.st_mode);
 333         if ((sourceFD < 0) || (destFD < 0)) {
 334                 count = -1;
 335                 goto copyFile_out;
 336         }
 337
 338         copyBuf = CNEW (char, 4096);
 339         while (-1) {
 340                 ret = read (sourceFD, copyBuf, 4096);
 341                 if (ret <= 0)
 342                         break;
 343                 if (write (destFD, copyBuf, ret) < 0)
 344                         break;
 345                 count += ret;
 346         }
 347
 348 copyFile_out:
 349
 350         DROP (copyBuf);
 351         fdclose (&sourceFD);
 352         fdclose (&destFD);
 353         return count;
 354 }
 355