installer/mkarchive.c

   1 /* mkarchive.c
   2
   3    Part of the rfx installer (Main program).
   4
   5    Copyright (c) 2004-2008 Matthias Kramm <kramm@quiss.org>
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  20
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include <unistd.h>
  24 #include <sys/stat.h>
  25 #include <fcntl.h>
  26 #include <memory.h>
  27 #include <zlib.h>
  28 #define ZLIB_BUFFER_SIZE 16384
  29
  30 typedef struct _writer
  31 {
  32     int (*write)(struct _writer*, void*data, int len);
  33     void (*finish)(struct _writer*);
  34     void *internal;
  35 } writer_t;
  36
  37 /* ---------------------------- file writer ------------------------------- */
  38
  39 typedef struct
  40 {
  41     FILE*fi;
  42 } filewrite_t;
  43 static int writer_filewrite_write(writer_t*w, void* data, int len)
  44 {
  45     filewrite_t * fw= (filewrite_t*)w->internal;
  46     return fwrite(data, len, 1, fw->fi);
  47 }
  48 static void writer_filewrite_finish(writer_t*w)
  49 {
  50     filewrite_t *mr = (filewrite_t*)w->internal;
  51     fclose(mr->fi);
  52     free(w->internal);
  53     memset(w, 0, sizeof(writer_t));
  54 }
  55 writer_t*writer_init_filewriter(char*filename)
  56 {
  57     writer_t*w = malloc(sizeof(writer_t));
  58     FILE*fi = fopen(filename, "wb");
  59     if(!fi) {
  60         perror(filename);
  61         return 0;
  62     }
  63     filewrite_t *mr = (filewrite_t *)malloc(sizeof(filewrite_t));
  64     mr->fi = fi;
  65     memset(w, 0, sizeof(writer_t));
  66     w->write = writer_filewrite_write;
  67     w->finish = writer_filewrite_finish;
  68     w->internal = mr;
  69     return w;
  70 }
  71
  72 /* ---------------------------- include file filter ------------------------------- */
  73
  74 typedef struct _ifwrite
  75 {
  76     FILE*fi;
  77     int bp;
  78     int pos;
  79     int last;
  80     char buf[1024];
  81     char*filename;
  82 } ifwrite_t;
  83
  84 static int writer_ifwrite_write(writer_t*out, void*data, int len)
  85 {
  86     ifwrite_t*i = (ifwrite_t*)out->internal;
  87     FILE*fo = i->fi;
  88     int t;
  89     for(t=0;t<len;t++) {
  90         unsigned char c = ((unsigned char*)data)[t];
  91         if(i->bp>=80) {
  92             fprintf(fo, "\"%s\"\n", i->buf);
  93             i->bp = 0;
  94         }
  95         if(c<=32 || c>0x7e || c=='"' || c == '\\' || c == '%'
  96         || (i->last && c>='0' && c<='9')
  97         || (i->last && c>='a' && c<='f')
  98         || (i->last && c>='A' && c<='F')
  99         ) {
 100             i->bp += sprintf(i->buf+i->bp, "\\x%x",c);
 101             i->last = 1;
 102         } else {
 103             i->buf[i->bp] = c;
 104             i->buf[i->bp+1] = 0;
 105             i->last = 0;
 106             i->bp++;
 107         }
 108         i->pos++;
 109     }
 110 }
 111 static void writer_ifwrite_finish(writer_t*w)
 112 {
 113     ifwrite_t *i= (ifwrite_t*)w->internal;
 114     fprintf(i->fi, "\"%s\"\n", i->buf);
 115     fprintf(i->fi, ";\n");
 116     fprintf(i->fi, "int crndata_len = %d;\n", i->pos);
 117     fclose(i->fi);
 118     printf("wrote file %s\n", i->filename);
 119     free(w->internal);w->internal = 0;
 120 }
 121
 122 writer_t*writer_init_includewriter(char*filename)
 123 {
 124     writer_t*w = malloc(sizeof(writer_t));
 125     FILE*fi = fopen(filename, "wb");
 126     memset(w, 0, sizeof(writer_t));
 127     w->write = writer_ifwrite_write;
 128     w->finish = writer_ifwrite_finish;
 129     ifwrite_t*i = (ifwrite_t *)malloc(sizeof(ifwrite_t));
 130     i->fi = fi;
 131     i->pos = 0;
 132     i->bp=0;
 133     i->last = 0;
 134     i->filename = filename;
 135     w->internal = i;
 136
 137     fprintf(i->fi, "char* crndata =\n");
 138     return w;
 139
 140 }
 141
 142 /* ---------------------------- zlibdeflate writer -------------------------- */
 143
 144 struct zlibdeflate_t
 145 {
 146     z_stream zs;
 147     writer_t*output;
 148     int written;
 149     int zwritten;
 150     unsigned char writebuffer[ZLIB_BUFFER_SIZE];
 151 };
 152
 153 static void zlib_error(int ret, char* msg, z_stream*zs)
 154 {
 155     fprintf(stderr, "%s: zlib error (%d): last zlib error: %s\n",
 156           msg,
 157           ret,
 158           zs->msg?zs->msg:"unknown");
 159     perror("errno:");
 160     exit(1);
 161 }
 162
 163 static int writer_zlibdeflate_write(writer_t*writer, void* data, int len)
 164 {
 165     struct zlibdeflate_t*z = (struct zlibdeflate_t*)writer->internal;
 166     int ret;
 167
 168     if(!z) {
 169         fprintf(stderr, "zlib not initialized!\n");
 170         return 0;
 171     }
 172     if(!len)
 173         return 0;
 174
 175     z->zs.next_in = (Bytef *)data;
 176     z->zs.avail_in = len;
 177
 178     while(1) {
 179         ret = deflate(&z->zs, Z_NO_FLUSH);
 180
 181         if (ret != Z_OK) zlib_error(ret, "bitio:deflate_deflate", &z->zs);
 182
 183         if(z->zs.next_out != z->writebuffer) {
 184             z->zwritten += z->zs.next_out - (Bytef*)z->writebuffer;
 185             z->output->write(z->output, z->writebuffer, z->zs.next_out - (Bytef*)z->writebuffer);
 186             z->zs.next_out = z->writebuffer;
 187             z->zs.avail_out = ZLIB_BUFFER_SIZE;
 188         }
 189
 190         if(!z->zs.avail_in) {
 191             break;
 192         }
 193     }
 194     z->written += len;
 195     return len;
 196 }
 197 static void writer_zlibdeflate_finish(writer_t*writer)
 198 {
 199     struct zlibdeflate_t*z = (struct zlibdeflate_t*)writer->internal;
 200     writer_t*output;
 201     int ret;
 202     if(!z)
 203         return;
 204     output= z->output;
 205     while(1) {
 206         ret = deflate(&z->zs, Z_FINISH);
 207         if (ret != Z_OK &&
 208             ret != Z_STREAM_END) zlib_error(ret, "bitio:deflate_finish", &z->zs);
 209
 210         if(z->zs.next_out != z->writebuffer) {
 211             z->zwritten += z->zs.next_out - (Bytef*)z->writebuffer;
 212             z->output->write(z->output, z->writebuffer, z->zs.next_out - (Bytef*)z->writebuffer);
 213             z->zs.next_out = z->writebuffer;
 214             z->zs.avail_out = ZLIB_BUFFER_SIZE;
 215         }
 216
 217         if (ret == Z_STREAM_END) {
 218             break;
 219
 220         }
 221     }
 222     ret = deflateEnd(&z->zs);
 223     if (ret != Z_OK) zlib_error(ret, "bitio:deflate_end", &z->zs);
 224
 225     if(z->written) {
 226         printf("Compression ratio: %.2f%% (%d bytes of input data, %d bytes of output data)\n",
 227                 z->zwritten*100.0 / z->written,
 228                 z->written, z->zwritten);
 229     } else {
 230         printf("Compression ratio: 0%% (0 bytes of input data, %d bytes of output data)\n", z->zwritten);
 231     }
 232
 233     free(writer->internal);
 234     memset(writer, 0, sizeof(writer_t));
 235     output->finish(output);
 236 }
 237 writer_t*writer_init_zwriter(writer_t*output)
 238 {
 239     writer_t*w = malloc(sizeof(writer_t));
 240     struct zlibdeflate_t*z;
 241     int ret;
 242     memset(w, 0, sizeof(writer_t));
 243     z = (struct zlibdeflate_t*)malloc(sizeof(struct zlibdeflate_t));
 244     memset(z, 0, sizeof(struct zlibdeflate_t));
 245     w->internal = z;
 246     w->write = writer_zlibdeflate_write;
 247     w->finish = writer_zlibdeflate_finish;
 248     z->output = output;
 249     memset(&z->zs,0,sizeof(z_stream));
 250     z->zs.zalloc = Z_NULL;
 251     z->zs.zfree  = Z_NULL;
 252     z->zs.opaque = Z_NULL;
 253     ret = deflateInit(&z->zs, 9);
 254     if (ret != Z_OK) zlib_error(ret, "bitio:deflate_init", &z->zs);
 255     z->zs.next_out = z->writebuffer;
 256     z->zs.avail_out = ZLIB_BUFFER_SIZE;
 257     z->written = 0;
 258     z->zwritten = 0;
 259     return w;
 260 }
 261
 262 /* ------------------------------- main ----------- ------------------------------- */
 263
 264 static int compare_filenames(const void*_n1, const void*_n2)
 265 {
 266     const char*s1 = *(const char**)_n1;
 267     const char*s2 = *(const char**)_n2;
 268
 269     char*e1 = strrchr(s1, '.');
 270     char*e2 = strrchr(s2, '.');
 271     if(!e1 && !e2)
 272         return 0;
 273     if(e1 && !e2)
 274         return 1;
 275     if(!e1 && e2)
 276         return -1;
 277     int c = strcasecmp(e1+1,e2+1);
 278     if(c)
 279         return c;
 280     return strcasecmp(s1,s2);
 281 }
 282
 283 int main (int argn, char*argv[])
 284 {
 285     int t;
 286     char buf[320];
 287     int num = 0;
 288
 289     int fullsize = 0;
 290     for(t=1;t<argn;t++)
 291     {
 292         if(argv[t][0]!='-')
 293         {
 294             FILE*fi=fopen(argv[t],"rb");
 295             if(fi) {
 296                 fseek(fi,0,SEEK_END);
 297                 long l=ftell(fi);
 298                 fclose(fi);
 299                 fullsize += l;
 300                 num++;
 301             }
 302         }
 303     }
 304
 305
 306 #ifdef ZLIB
 307     writer_t*include_writer = writer_init_includewriter("crnfiles.c");
 308     writer_t*zwriter = writer_init_zwriter(include_writer);
 309 #else //LZMA
 310     unlink("crnfiles.dat");
 311     unlink("crnfiles.7z");
 312     unlink("crnfiles.c");
 313     writer_t*zwriter = writer_init_filewriter("crnfiles.dat");
 314 #endif
 315     unsigned char n1=num;
 316     unsigned char n2=num>>8;
 317     unsigned char n3=num>>16;
 318     unsigned char n4=num>>24;
 319     zwriter->write(zwriter,&n1,1);
 320     zwriter->write(zwriter,&n2,1);
 321     zwriter->write(zwriter,&n3,1);
 322     zwriter->write(zwriter,&n4,1);
 323
 324     qsort(argv+1, argn-1, sizeof(argv[0]), compare_filenames);
 325
 326     for(t=1;t<argn;t++)
 327     {
 328             if(argv[t][0]!='-')
 329             {
 330                     FILE*fi=fopen(argv[t],"rb");
 331                     if(fi)
 332                     {
 333                             fseek(fi,0,SEEK_END);
 334                             long l=ftell(fi);
 335                             fseek(fi,0,SEEK_SET);
 336
 337                             char*buf=(char*)malloc(l);
 338                             char*id="NUL";
 339                             struct stat st;
 340                             fstat(fileno(fi),&st);
 341                             if(S_ISDIR(st.st_mode)) {id ="DIR";l=0;}
 342                             else if(strstr(argv[t],".swf")) id="SWF";
 343                             else if(strstr(argv[t],".gif")) id="PIC";
 344                             else if(strstr(argv[t],".png")) id="PIC";
 345                             else if(strstr(argv[t],".jpeg")) id="PIC";
 346                             else if(strstr(argv[t],".jpg")) id="PIC";
 347                             else if(strstr(argv[t],".tif")) id="PIC";
 348                             else if(strstr(argv[t],".ico")) id="PIC";
 349                             else if(strstr(argv[t],".c")) id="SRC";
 350                             else if(strstr(argv[t],".cc")) id="SRC";
 351                             else if(strstr(argv[t],".cpp")) id="SRC";
 352                             else if(strstr(argv[t],".h")) id="SRC";
 353                             else if(strstr(argv[t],".class")) id="CLA";
 354                             else if(strstr(argv[t],".java")) id="SRC";
 355                             else if(strstr(argv[t],".exe")) id="EXE";
 356                             else if(strstr(argv[t],".ttf")) id="FON";
 357                             else if(strstr(argv[t],".pfa")) id="FON";
 358                             else if(strstr(argv[t],".pfb")) id="FON";
 359                             else if(strstr(argv[t],".afm")) id="FON";
 360                             else if(strstr(argv[t],".1")) id="DOC";
 361                             else if(strstr(argv[t],".doc")) id="DOC";
 362                             else if(strstr(argv[t],".txt")) id="TXT";
 363                             else if(strstr(argv[t],".hlp")) id="DOC";
 364                             else if(strstr(argv[t],".dll")) id="DLL";
 365
 366                             fread(buf,l,1,fi);
 367                             zwriter->write(zwriter,id,3);
 368                             unsigned char b1=l;
 369                             unsigned char b2=l>>8;
 370                             unsigned char b3=l>>16;
 371                             unsigned char b4=l>>24;
 372                             zwriter->write(zwriter,&b1,1);
 373                             zwriter->write(zwriter,&b2,1);
 374                             zwriter->write(zwriter,&b3,1);
 375                             zwriter->write(zwriter,&b4,1);
 376                             int sl=strlen(argv[t]);
 377                             if(sl>255) {
 378                                 fprintf(stderr, "Error: filename %s too long\n", argv[t]);
 379                             }
 380                             unsigned char b = sl;
 381                             zwriter->write(zwriter,&b,1); //write filename len
 382                             zwriter->write(zwriter,argv[t],sl); //write filename
 383                             zwriter->write(zwriter,buf,l); //write data
 384                             fprintf(stderr,"[%s] %s: %d bytes written.\n", id, argv[t], l);
 385                             fclose(fi);
 386                             free(buf);
 387                     }
 388                     else
 389                     {
 390                             fprintf(stderr,"%s not found.\n", argv[t]);
 391                     }
 392             }
 393     }
 394     char*id_end = "END";
 395     zwriter->write(zwriter,id_end,3);
 396     zwriter->finish(zwriter);
 397
 398 #ifndef ZLIB
 399     if(system("do_lzma e crnfiles.dat crnfiles.7z")&0xff00) {
 400         perror("do_lzma");
 401         exit(1);
 402     }
 403     FILE*fi = fopen("crnfiles.7z", "rb");
 404     if(!fi) {
 405         perror("crnfiles.7z");
 406         exit(1);
 407     }
 408     writer_t*w = writer_init_includewriter("crnfiles.c");
 409     while(!feof(fi)) {
 410         char buf[4096];
 411         int len = fread(buf,1,4096,fi);
 412         if(!len)
 413             break;
 414         w->write(w, buf, len);
 415     }
 416     w->finish(w);
 417     fclose(fi);
 418     if(unlink("crnfiles.dat")) {
 419         perror("crnfiles.dat");
 420         exit(1);
 421     }
 422     if(unlink("crnfiles.7z")) {
 423         perror("crnfiles.7z");
 424         exit(1);
 425     }
 426 #endif
 427
 428     fi = fopen("crnfiles.c", "ab+");
 429     fprintf(fi, "\nint crn_decompressed_size=%d;\n", fullsize);
 430     fclose(fi);
 431
 432     return 0;
 433 }
 434