From 27d3cf31609704bc4428d6c4487e1bef1eaa9d95 Mon Sep 17 00:00:00 2001 From: Dimitri Sokolyuk Date: Sat, 27 Mar 2004 04:35:47 +0000 Subject: initial import 0.1-alpha --- Makefile | 6 + src/Makefile | 9 + src/main.c | 172 +++++++ tgeb/Makefile | 20 + tgeb/anbieter.c | 124 +++++ tgeb/ausland.c | 81 ++++ tgeb/common.c | 95 ++++ tgeb/shlib_version | 2 + tgeb/tarife.c | 161 +++++++ tgeb/tgebdat.h | 161 +++++++ tgeb/tgebup.h | 18 + tgeb/unzip.c | 1294 ++++++++++++++++++++++++++++++++++++++++++++++++++++ tgeb/unzip.h | 275 +++++++++++ tgeb/update.c | 129 ++++++ 14 files changed, 2547 insertions(+) create mode 100644 Makefile create mode 100644 src/Makefile create mode 100644 src/main.c create mode 100644 tgeb/Makefile create mode 100644 tgeb/anbieter.c create mode 100644 tgeb/ausland.c create mode 100644 tgeb/common.c create mode 100644 tgeb/shlib_version create mode 100644 tgeb/tarife.c create mode 100644 tgeb/tgebdat.h create mode 100644 tgeb/tgebup.h create mode 100644 tgeb/unzip.c create mode 100644 tgeb/unzip.h create mode 100644 tgeb/update.c diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..cfdf5da --- /dev/null +++ b/Makefile @@ -0,0 +1,6 @@ +# $Id$ + +SUBDIR+= tgeb src +#SUBDIR+= gui + +.include diff --git a/src/Makefile b/src/Makefile new file mode 100644 index 0000000..318328e --- /dev/null +++ b/src/Makefile @@ -0,0 +1,9 @@ +# $Id$ + +PROG= tgeb +SRCS= main.c +CFLAGS+= -Wall -I.. +LDADD+= -L../tgeb -ltgeb -lz +NOMAN= + +. include diff --git a/src/main.c b/src/main.c new file mode 100644 index 0000000..f7fc417 --- /dev/null +++ b/src/main.c @@ -0,0 +1,172 @@ +/* $Id$ */ +/* + * Copyright (c) 2004 demon + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +extern char *__progname; +const char *copyright = "$ TGeb parasite 0.1 -" \ + " Copyright (c) 2004 demon $"; + +void usage(void); +void prdt(struct an_d *, struct ta_d *); + +int +main(int argc, char **argv) +{ + struct an *an; + struct ta *ta; + struct au *au; + struct sorted sd; + char ch; + int reg = 0; + int flags = 0; + time_t tval = time(NULL); + struct tm *tm = localtime(&tval); + int time = tm->tm_hour; + int quant = 3; + int i; + + while ((ch = getopt(argc, argv, "CRP9nrfo12eONE?h:q:u")) != -1) + switch (ch) { + case 'u': /* update */ + printf("%s: updating database...\n", __progname); + tgeb_update(tm); + exit(0); + break; + case 'h': /* time hour */ + time = atoi(optarg); + if (time >= 24) + errx(1, "wrong time"); + break; + case 'q': /* time hour */ + quant = atoi(optarg); + break; + case 'C': /* Call by Call */ + flags ^= T_CBC; + break; + case 'R': /* Call by Call with reg. */ + flags ^= T_CBCR; + break; + case 'P': /* Preselect */ + flags ^= T_PRES; + break; + case '9': /* 0190 */ + flags ^= T_0190; + break; + case 'n': /* Nah */ + reg = NAH_W; + break; + case 'r': /* Reg 50km */ + reg = REG_W; + break; + case 'f': /* Fern */ + reg = FERN_W; + break; + case 'o': /* Ort */ + reg = ORT_W; + break; + case '1': /* D1 */ + reg = D1_W; + break; + case '2': /* D2 */ + reg = D2_W; + break; + case 'e': /* E+ */ + reg = EP_W; + break; + case 'O': /* o2 */ + reg = O2_W; + break; +/* + case 'N': // Now + if ((tm->tm_wday == 0) || (tm->tm_wday == 6)) + reg++; + break; + case 'E': // Wochenende + reg++; + break; +*/ + case '?': + default: + usage(); + } + argc -= optind; + argv += optind; + + if (!(flags & ~T_0190)) /* default T_CBC, ignore T_0190 */ + flags ^= T_CBC; + + if ((tm->tm_wday == 0) || (tm->tm_wday == 6)) + reg++; + + an = tgeb_read_an("anbieter.dat"); + au = tgeb_read_au("ausland.dat"); + ta = tgeb_read_ta("tarife.dat", au); + + if (an->e_q != ta->q) + errx(1, "database missmatch - obtain new files"); + + sd = tgeb_select(ta, an, reg, flags, time); + + for (i = 0; i < sd.q; i++) { + prdt(&an->e[sd.id[i]], sd.data[i]); + if ((i + 1) >= quant) + break; + } + + exit(0); + return 0; +} + +void +prdt(struct an_d * an_d, struct ta_d * ta_d) +{ + printf("(%.2u)\tPrefix:\t%s\n" + "\tName:\t%s" + " (%s)\n", + an_d->id, + an_d->pref, + an_d->h->name, + an_d->serv); + printf("\tValid:\t%.2u:00 - %.2u:00 h\n", + ta_d->prev ? ta_d->prev->time : (char)NULL, + ta_d->time); + printf("\tFee:\t%.2f ct/min" + " + %.2f ct\n" + "\tTiming:\t%u/%u s\n", + ta_d->fee * 100, + ta_d->dfee * 100, + ta_d->t1, + ta_d->t2); + printf("\n"); + return; +} + +void +usage() +{ + printf("Usage: %s [-nrfo12eO] [-NWE]\n", __progname); + exit(1); + return; +} diff --git a/tgeb/Makefile b/tgeb/Makefile new file mode 100644 index 0000000..42630c3 --- /dev/null +++ b/tgeb/Makefile @@ -0,0 +1,20 @@ +# $Id$ + +LIB= tgeb +SRCS= anbieter.c ausland.c tarife.c common.c update.c unzip.c +HDRS= tgebdat.h tgebup.h +#CFLAGS+= -I../unzip +NOMAN= +NOPROFILE= +NOPIC= + +includes: + @cd ${.CURDIR}; for i in $(HDRS); do \ + j="cmp -s $$i ${DESTDIR}/usr/include/$$i || \ + ${INSTALL} ${INSTALL_COPY} -o ${BINOWN} -g ${BINGRP} \ + -m 444 $$i ${DESTDIR}/usr/include"; \ + echo $$j; \ + eval "$$j"; \ + done + +.include diff --git a/tgeb/anbieter.c b/tgeb/anbieter.c new file mode 100644 index 0000000..575ed03 --- /dev/null +++ b/tgeb/anbieter.c @@ -0,0 +1,124 @@ +/* $Id$ */ +/* + * Copyright (c) 2004 demon + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include +#include +#include "tgebdat.h" + +static void rhdr_an(struct an *, FILE *); /* read header */ +static void rent_an(struct an *, FILE *); /* read entries */ +static void resort_an(struct an *); + +struct an * +tgeb_read_an(char *file) +{ + struct an *an; + FILE *fd; + + if (!(fd = fopen(file, "r"))) + err(1, "fopen %s", file); + + if (!(an = (struct an *) malloc(sizeof(struct an)))) + err(1, "malloc"); + + rhdr_an(an, fd); + rent_an(an, fd); + + fclose(fd); + return an; +} + +void +rhdr_an(struct an * an, FILE * fd) +{ + int i; + + fread(&an->q, sizeof(an->q), 1, fd); + if (!(an->h = (struct an_hdr *) calloc(an->q, sizeof(struct an_hdr)))) + err(1, "malloc"); + + fseek(fd, 2, SEEK_SET); + for (i = 0; i < an->q; i++) { + _tgeb_sread(&an->h[i].name, fd); + _tgeb_sread(&an->h[i].mail, fd); + _tgeb_sread(&an->h[i].url, fd); + fread(&an->h[i].off, sizeof(an->h[i].off), 1, fd); + an->h[i].off--; + } + return; +} + +void +rent_an(struct an * an, FILE * fd) +{ + int i, j; + + an->e_q = 0; + for (i = 0; i < an->q; i++) { + fseek(fd, an->h[i].off, SEEK_SET); + fread(&an->h[i].q, sizeof(an->h[i].q), 1, fd); + if (!(an->h[i].d = (struct an_d *) + calloc(an->h[i].q, sizeof(struct an_d)))) + err(1, "malloc"); + for (j = 0; j < an->h[i].q; j++) { + an->h[i].d[j].h = &an->h[i]; + _tgeb_sread(&an->h[i].d[j].serv, fd); + _tgeb_sread(&an->h[i].d[j].pref, fd); + fread(&an->h[i].d[j].id, + sizeof(an->h[i].d[j].id), 1, fd); + if (an->h[i].d[j].id > an->e_q) + an->e_q = an->h[i].d[j].id; + _tgeb_sread(&an->h[i].d[j].valf, fd); + _tgeb_sread(&an->h[i].d[j].valt, fd); + fread(&an->h[i].d[j].type, + sizeof(an->h[i].d[j].type), 1, fd); + fread(&an->h[i].d[j].mvol, + sizeof(an->h[i].d[j].mvol), 1, fd); + fread(&an->h[i].d[j].bfee, + sizeof(an->h[i].d[j].bfee), 1, fd); + fread(&an->h[i].d[j].afee, + sizeof(an->h[i].d[j].afee), 1, fd); + _tgeb_sread(&an->h[i].d[j].url, fd); + _tgeb_sread(&an->h[i].d[j].url2, fd); + _tgeb_sread(&an->h[i].d[j].phone, fd); + _tgeb_sread(&an->h[i].d[j].mail, fd); + _tgeb_sread(&an->h[i].d[j].x, fd); + fread(&an->h[i].d[j].reg, + sizeof(an->h[i].d[j].reg), 1, fd); + _tgeb_sread(&an->h[i].d[j].rurl, fd); + _tgeb_sread(&an->h[i].d[j].rfax, fd); + } + } + resort_an(an); + return; +} + +void +resort_an(struct an * an) +{ + int i, j; + + if (!(an->e = (struct an_d *) calloc(an->e_q, sizeof(struct an_d)))) + err(1, "malloc"); + for (i = 0; i < an->e_q; i++) { + for (j = 0; j < an->h[i].q; j++) { + an->e[an->h[i].d[j].id - 1] = an->h[i].d[j]; + } + } + return; +} diff --git a/tgeb/ausland.c b/tgeb/ausland.c new file mode 100644 index 0000000..f7e32a3 --- /dev/null +++ b/tgeb/ausland.c @@ -0,0 +1,81 @@ +/* $Id$ */ +/* + * Copyright (c) 2004 demon + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include +#include +#include "tgebdat.h" + +static void rhdr_au(struct au *, FILE *); /* read header */ +static void rent_au(struct au *, FILE *); /* read entries */ + +struct au * +tgeb_read_au(char *file) +{ + struct au *au; + FILE *fd; + + if (!(fd = fopen(file, "r"))) + err(1, "fopen %s", file); + + if (!(au = (struct au *) malloc(sizeof(struct au)))) + err(1, "malloc"); + + rhdr_au(au, fd); + rent_au(au, fd); + + fclose(fd); + return au; +} + +void +rhdr_au(struct au * au, FILE * fd) +{ + fread(&au->l, sizeof(au->l), 1, fd); + fread(&au->q, sizeof(au->q), 1, fd); + return; +} + +void +rent_au(struct au * au, FILE * fd) +{ + int i, j; + + if (!(au->d = (struct au_d *) + calloc(au->l, sizeof(struct au_d)))) + err(1, "malloc"); + if (!(au->max = (unsigned short *) + calloc(au->q, sizeof(unsigned short)))) + err(1, "malloc"); + + fseek(fd, 4, SEEK_SET); + for (i = 0; i < au->l; i++) { + au->d[i].id = (unsigned short *) + calloc(au->q, sizeof(unsigned short)); + for (j = 0; j < au->q; j++) { + fread(&au->d[i].id[j], sizeof(au->d[i].id[j]), 1, fd); + if (au->d[i].id[j] > au->max[j]) + au->max[j] = au->d[i].id[j]; + } + } + + for (i = 0; i < au->l; i++) { + _tgeb_sread(&au->d[i].land, fd); + _tgeb_sread(&au->d[i].dial, fd); + } + return; +} diff --git a/tgeb/common.c b/tgeb/common.c new file mode 100644 index 0000000..22625c8 --- /dev/null +++ b/tgeb/common.c @@ -0,0 +1,95 @@ +/* $Id$ */ +/* + * Copyright (c) 2004 demon + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include +#include +#include +#include "tgebdat.h" + +struct sort { + int id; + float fee; +}; + +static int compare(const void *val1, const void *val2); +static struct ta_d * selectdt(struct ta_d * d, int time); +static void prdt(struct an_d * an_d, struct ta_d * ta_d); + +void +_tgeb_sread(char **data, FILE * fd) +{ + unsigned short len; + + fread(&len, sizeof(len), 1, fd); + if (!(*data = (char *) calloc(len + 1, sizeof(**data)))) + err(1, "malloc"); + fread(*data, sizeof(**data), len, fd); + return; +} + +struct sorted +tgeb_select(struct ta * ta, struct an * an, + int reg, int flags, int time) +{ + int i; + int q = 0; + struct sort *s = (struct sort *) calloc(an->e_q, sizeof(struct sort)); + struct sorted sd; + + for (i = 0; i < an->e_q; i++) { + if (!(flags & an->e[i].type)) + continue; + if (!((flags & T_0190) || strncmp("0190", an->e[i].pref, 4))) + continue; + if (ta->h[i].in[reg].off) { + s[q].id = i; + s[q].fee = (selectdt(ta->h[i].in[reg].data, time))->fee; + q++; + } + } + qsort(s, q, sizeof(*s), compare); + sd.q = q; + if (!(sd.id = calloc(q, sizeof(sd.id)))) + err(1, "malloc"); + if (!(sd.data = calloc(q, sizeof(sd.data)))) + err(1, "malloc"); + for (i = 0; i < q; i++) { + sd.id[i] = s[i].id; + sd.data[i] = selectdt(ta->h[s[i].id].in[reg].data, time); + } + + free(s); + return sd; +} + +int +compare(const void *val1, const void *val2) +{ + struct sort *s1 = (struct sort *) val1; + struct sort *s2 = (struct sort *) val2; + + return ((s1->fee > s2->fee) ? 1 : (s1->fee < s2->fee) ? -1 : 0); +} + +struct ta_d * +selectdt(struct ta_d * d, int time) +{ + if (time >= d->time) + return (selectdt(d->next, time)); + return d; +} diff --git a/tgeb/shlib_version b/tgeb/shlib_version new file mode 100644 index 0000000..3d7c908 --- /dev/null +++ b/tgeb/shlib_version @@ -0,0 +1,2 @@ +major=0 +minor=1 diff --git a/tgeb/tarife.c b/tgeb/tarife.c new file mode 100644 index 0000000..f73a7b5 --- /dev/null +++ b/tgeb/tarife.c @@ -0,0 +1,161 @@ +/* $Id$ */ +/* + * Copyright (c) 2004 demon + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include +#include +#include "tgebdat.h" + +static void rhdr_ta(struct ta *, FILE *); /* read header */ +static void ridx_ta(struct ta *, FILE *); /* read index */ +static void rdat_ta(struct ta *, FILE *); /* read data */ +static void rdat2_ta(struct ta_d *, FILE *); /* read chain */ +static void maxtoq(struct au *, struct ta *); + +struct ta * +tgeb_read_ta(char *file, struct au * au) +{ + struct ta *ta; + FILE *fd; + + if (!(fd = fopen(file, "r"))) + err(1, "fopen %s", file); + + if (!(ta = (struct ta *) malloc(sizeof(struct ta)))) + err(1, "malloc"); + + maxtoq(au, ta); + rhdr_ta(ta, fd); + ridx_ta(ta, fd); + rdat_ta(ta, fd); + + fclose(fd); + return ta; +} + +void +rhdr_ta(struct ta * ta, FILE * fd) +{ + int i; + + fread(&ta->q, sizeof(ta->q), 1, fd); + if (!(ta->h = (struct ta_hdr *) calloc(ta->q, sizeof(struct ta_hdr)))) + err(1, "malloc"); + + fseek(fd, 2, SEEK_SET); + for (i = 0; i < ta->q; i++) { + fread(&ta->h[i].off_in, sizeof(ta->h[i].off_in), 1, fd); + ta->h[i].off_in ? ta->h[i].off_in-- : ta->h[i].off_in; + fread(&ta->h[i].off_aus, sizeof(ta->h[i].off_aus), 1, fd); + ta->h[i].off_aus ? ta->h[i].off_aus-- : ta->h[i].off_aus; + } + return; +} + +void +ridx_ta(struct ta * ta, FILE * fd) +{ + int i, j; + + for (i = 0; i < ta->q; i++) { + /* read inland offsets */ + if (!(ta->h[i].in = (struct ta_idx *) + calloc(Q_IN, sizeof(struct ta_idx)))) + err(1, "malloc"); + fseek(fd, ta->h[i].off_in, SEEK_SET); + for (j = 0; j < Q_IN; j++) { + fread(&ta->h[i].in[j].off, + sizeof(ta->h[i].in[j].off), 1, fd); + if (ta->h[i].in[j].off) + ta->h[i].in[j].off--; + } + /* read ausland offsets */ + if (!(ta->h[i].aus = (struct ta_idx *) + calloc(ta->q_aus[i], sizeof(struct ta_idx)))) + err(1, "malloc"); + fseek(fd, ta->h[i].off_aus, SEEK_SET); + for (j = 0; j < ta->q_aus[i]; j++) { + fread(&ta->h[i].aus[j].off, + sizeof(ta->h[i].aus[j].off), 1, fd); + if (ta->h[i].aus[j].off) + ta->h[i].aus[j].off--; + } + } + return; +} + +void +rdat_ta(struct ta * ta, FILE * fd) +{ + int i, j; + + for (i = 0; i < ta->q; i++) { + /* read inland data */ + for (j = 0; j < Q_IN; j++) { + if (ta->h[i].in[j].off) { + fseek(fd, ta->h[i].in[j].off, SEEK_SET); + + if (!(ta->h[i].in[j].data = (struct ta_d *) + malloc(sizeof(struct ta_d)))) + err(1, "malloc"); + rdat2_ta(ta->h[i].in[j].data, fd); + } + } + /* read ausland data */ + for (j = 0; j < ta->q_aus[i]; j++) { + if (ta->h[i].aus[j].off) { + fseek(fd, ta->h[i].aus[j].off, SEEK_SET); + + if (!(ta->h[i].aus[j].data = (struct ta_d *) + malloc(sizeof(struct ta_d)))) + err(1, "malloc"); + rdat2_ta(ta->h[i].aus[j].data, fd); + } + } + } + return; +} + +void +rdat2_ta(struct ta_d * data, FILE * fd) +{ + fread(&data->time, sizeof(data->time), 1, fd); + fread(&data->dfee, sizeof(data->dfee), 1, fd); + fread(&data->fee, sizeof(data->fee), 1, fd); + fread(&data->t1, sizeof(data->t1), 1, fd); + fread(&data->t2, sizeof(data->t2), 1, fd); + if (data->time != 24) { + if (!(data->next = malloc(sizeof(struct ta_d)))) + err(1, "malloc"); + data->next->prev = data; + rdat2_ta(data->next, fd); + } + return; +} + +void +maxtoq(struct au * au, struct ta * ta) +{ + int i; + + if (!(ta->q_aus = (unsigned short *) + calloc(au->q, sizeof(unsigned short)))) + err(1, "malloc"); + for (i = 0; i < au->q; i++) + ta->q_aus[i] = au->max[i] * 2; + return; +} diff --git a/tgeb/tgebdat.h b/tgeb/tgebdat.h new file mode 100644 index 0000000..20f09f8 --- /dev/null +++ b/tgeb/tgebdat.h @@ -0,0 +1,161 @@ +/* $Id$ */ +/* + * Copyright (c) 2004 demon + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* + * anbieter.c + */ + +#define T_CC 0x00 /* calling card */ +#define T_CBC 0x01 /* call by call */ +#define T_CBCR 0x02 /* call by call with registration */ +#define T_RTR 0x03 /* router */ +#define T_PRES 0x04 /* preselection */ +#define T_TDA 0x05 /* deutsche telekom analog */ +#define T_TDI 0x06 /* deutsche telekom isdn */ +#define T_0190 0x08 /* 0190 */ + +struct an_d { + struct an_hdr *h; /* back-pointer to header */ + char *serv; /* service (e.g. string "call by call") */ + char *pref; /* prefix */ + unsigned int id; /* ID */ + char *valf; /* valid from */ + char *valt; /* valid to */ + unsigned short type; /* type of service (int value) */ + float mvol; /* mindest volume (Euro) */ + float bfee; /* base fee (0.001 Euro) */ + float afee; /* arrangement fee (0.001 Euro) */ + char *url; + char *url2; + char *phone; + char *mail; + char *x; /* XXX */ + unsigned short reg; /* registration (TRUE/FALSE) */ + char *rurl; /* registration url */ + char *rfax; /* registration fax */ +}; + +struct an_hdr { + unsigned int off; /* offset */ + unsigned short q; /* entry quantity */ + char *name; /* name */ + char *mail; /* e-mail */ + char *url; /* url */ + struct an_d *d; +}; + +struct an { + unsigned short q; /* provider quantity */ + struct an_hdr *h; /* header */ + unsigned short e_q; /* entries qantity */ + struct an_d *e; /* entries (id-sorted) */ +}; + +struct an *tgeb_read_an(char *file); + +/* + * ausland.c + */ + +struct au_d { + unsigned short *id; + char *land; + char *dial; +}; + +struct au_hdr { + struct an_d *d; + char *land; + char *dial; +}; + +struct au { + unsigned short q; /* quantity */ + unsigned short l; + struct au_d *d; + unsigned short *max; +}; + +struct au *tgeb_read_au(char *file); + +/* + * tarife.c + */ + +#define NAH_W 0x00 +#define NAH_E 0x01 +#define REG_W 0x02 +#define REG_E 0x03 +#define FERN_W 0x04 +#define FERN_E 0x05 +#define ORT_W 0x06 +#define ORT_E 0x07 +#define D1_W 0x08 +#define D1_E 0x09 +#define D2_W 0x0A +#define D2_E 0x0B +#define EP_W 0x0C +#define EP_E 0x0D +#define O2_W 0x0E +#define O2_E 0x0F + +#define AUS_W 0x00 +#define AUS_E 0x01 +#define Q_IN 16 + +struct ta_d { + unsigned short time; /* valid till */ + float dfee; /* dial-in fee */ + float fee; /* fee (Brutto) */ + unsigned short t1; /* timing 1 */ + unsigned short t2; /* timing 2 */ + struct ta_d *next; /* next data block in chain */ + struct ta_d *prev; /* prevision data block in chain */ +}; + +struct ta_idx { + unsigned int off; /* region / day-of-week offset */ + struct ta_d *data; +}; + +struct ta_hdr { + struct ta_idx *in; + unsigned int off_in; + struct ta_idx *aus; + unsigned int off_aus; +}; + +struct ta { /* file offset 0 */ + unsigned short q; /* quantity provider */ + unsigned short *q_aus; /* entrys quantity per provider */ + struct ta_hdr *h; +}; + +struct ta *tgeb_read_ta(char *file, struct au *); + +/* + *common.c + */ + +struct sorted { + int q; + int *id; + struct ta_d **data; +}; + +void _tgeb_sread(char **, FILE *); /* read string */ +struct sorted tgeb_select(struct ta *, struct an *, int reg, int flags, int time); diff --git a/tgeb/tgebup.h b/tgeb/tgebup.h new file mode 100644 index 0000000..0d2f15e --- /dev/null +++ b/tgeb/tgebup.h @@ -0,0 +1,18 @@ +/* $Id$ */ +/* + * Copyright (c) 2004 demon + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +void tgeb_update(struct tm *); diff --git a/tgeb/unzip.c b/tgeb/unzip.c new file mode 100644 index 0000000..30a9371 --- /dev/null +++ b/tgeb/unzip.c @@ -0,0 +1,1294 @@ +/* unzip.c -- IO on .zip files using zlib + Version 0.15 beta, Mar 19th, 1998, + + Read unzip.h for more info +*/ + + +#include +#include +#include +#include +#include "unzip.h" + +#ifdef STDC +# include +# include +# include +#endif +#ifdef NO_ERRNO_H + extern int errno; +#else +# include +#endif + + +#ifndef local +# define local static +#endif +/* compile with -Dlocal if your debugger can't find static symbols */ + + + +#if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) && \ + !defined(CASESENSITIVITYDEFAULT_NO) +#define CASESENSITIVITYDEFAULT_NO +#endif + + +#ifndef UNZ_BUFSIZE +#define UNZ_BUFSIZE (16384) +#endif + +#ifndef UNZ_MAXFILENAMEINZIP +#define UNZ_MAXFILENAMEINZIP (256) +#endif + +#ifndef ALLOC +# define ALLOC(size) (malloc(size)) +#endif +#ifndef TRYFREE +# define TRYFREE(p) {if (p) free(p);} +#endif + +#define SIZECENTRALDIRITEM (0x2e) +#define SIZEZIPLOCALHEADER (0x1e) + + +/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ + +#ifndef SEEK_CUR +#define SEEK_CUR 1 +#endif + +#ifndef SEEK_END +#define SEEK_END 2 +#endif + +#ifndef SEEK_SET +#define SEEK_SET 0 +#endif + +const char unz_copyright[] = + " unzip 0.15 Copyright 1998 Gilles Vollant "; + +/* unz_file_info_interntal contain internal info about a file in zipfile*/ +typedef struct unz_file_info_internal_s +{ + uLong offset_curfile;/* relative offset of local header 4 bytes */ +} unz_file_info_internal; + + +/* file_in_zip_read_info_s contain internal information about a file in zipfile, + when reading and decompress it */ +typedef struct +{ + char *read_buffer; /* internal buffer for compressed data */ + z_stream stream; /* zLib stream structure for inflate */ + + uLong pos_in_zipfile; /* position in byte on the zipfile, for fseek*/ + uLong stream_initialised; /* flag set if stream structure is initialised*/ + + uLong offset_local_extrafield;/* offset of the local extra field */ + uInt size_local_extrafield;/* size of the local extra field */ + uLong pos_local_extrafield; /* position in the local extra field in read*/ + + uLong crc32; /* crc32 of all data uncompressed */ + uLong crc32_wait; /* crc32 we must obtain after decompress all */ + uLong rest_read_compressed; /* number of byte to be decompressed */ + uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/ + FILE* file; /* io structore of the zipfile */ + uLong compression_method; /* compression method (0==store) */ + uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ +} file_in_zip_read_info_s; + + +/* unz_s contain internal information about the zipfile +*/ +typedef struct +{ + FILE* file; /* io structore of the zipfile */ + unz_global_info gi; /* public global information */ + uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ + uLong num_file; /* number of the current file in the zipfile*/ + uLong pos_in_central_dir; /* pos of the current file in the central dir*/ + uLong current_file_ok; /* flag about the usability of the current file*/ + uLong central_pos; /* position of the beginning of the central dir*/ + + uLong size_central_dir; /* size of the central directory */ + uLong offset_central_dir; /* offset of start of central directory with + respect to the starting disk number */ + + unz_file_info cur_file_info; /* public info about the current file in zip*/ + unz_file_info_internal cur_file_info_internal; /* private info about it*/ + file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current + file if we are decompressing it */ +} unz_s; + + +/* =========================================================================== + Read a byte from a gz_stream; update next_in and avail_in. Return EOF + for end of file. + IN assertion: the stream s has been successfully opened for reading. +*/ + + +local int unzlocal_getByte(fin,pi) + FILE *fin; + int *pi; +{ + unsigned char c; + int err = fread(&c, 1, 1, fin); + if (err==1) + { + *pi = (int)c; + return UNZ_OK; + } + else + { + if (ferror(fin)) + return UNZ_ERRNO; + else + return UNZ_EOF; + } +} + + +/* =========================================================================== + Reads a long in LSB order from the given gz_stream. Sets +*/ +local int unzlocal_getShort (fin,pX) + FILE* fin; + uLong *pX; +{ + uLong x ; + int i; + int err; + + err = unzlocal_getByte(fin,&i); + x = (uLong)i; + + if (err==UNZ_OK) + err = unzlocal_getByte(fin,&i); + x += ((uLong)i)<<8; + + if (err==UNZ_OK) + *pX = x; + else + *pX = 0; + return err; +} + +local int unzlocal_getLong (fin,pX) + FILE* fin; + uLong *pX; +{ + uLong x ; + int i; + int err; + + err = unzlocal_getByte(fin,&i); + x = (uLong)i; + + if (err==UNZ_OK) + err = unzlocal_getByte(fin,&i); + x += ((uLong)i)<<8; + + if (err==UNZ_OK) + err = unzlocal_getByte(fin,&i); + x += ((uLong)i)<<16; + + if (err==UNZ_OK) + err = unzlocal_getByte(fin,&i); + x += ((uLong)i)<<24; + + if (err==UNZ_OK) + *pX = x; + else + *pX = 0; + return err; +} + + +/* My own strcmpi / strcasecmp */ +local int strcmpcasenosensitive_internal (fileName1,fileName2) + const char* fileName1; + const char* fileName2; +{ + for (;;) + { + char c1=*(fileName1++); + char c2=*(fileName2++); + if ((c1>='a') && (c1<='z')) + c1 -= 0x20; + if ((c2>='a') && (c2<='z')) + c2 -= 0x20; + if (c1=='\0') + return ((c2=='\0') ? 0 : -1); + if (c2=='\0') + return 1; + if (c1c2) + return 1; + } +} + + +#ifdef CASESENSITIVITYDEFAULT_NO +#define CASESENSITIVITYDEFAULTVALUE 2 +#else +#define CASESENSITIVITYDEFAULTVALUE 1 +#endif + +#ifndef STRCMPCASENOSENTIVEFUNCTION +#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal +#endif + +/* + Compare two filename (fileName1,fileName2). + If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp) + If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi + or strcasecmp) + If iCaseSenisivity = 0, case sensitivity is defaut of your operating system + (like 1 on Unix, 2 on Windows) + +*/ +extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity) + const char* fileName1; + const char* fileName2; + int iCaseSensitivity; +{ + if (iCaseSensitivity==0) + iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE; + + if (iCaseSensitivity==1) + return strcmp(fileName1,fileName2); + + return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2); +} + +#define BUFREADCOMMENT (0x400) + +/* + Locate the Central directory of a zipfile (at the end, just before + the global comment) +*/ +local uLong unzlocal_SearchCentralDir(fin) + FILE *fin; +{ + unsigned char* buf; + uLong uSizeFile; + uLong uBackRead; + uLong uMaxBack=0xffff; /* maximum size of global comment */ + uLong uPosFound=0; + + if (fseek(fin,0,SEEK_END) != 0) + return 0; + + + uSizeFile = ftell( fin ); + + if (uMaxBack>uSizeFile) + uMaxBack = uSizeFile; + + buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); + if (buf==NULL) + return 0; + + uBackRead = 4; + while (uBackReaduMaxBack) + uBackRead = uMaxBack; + else + uBackRead+=BUFREADCOMMENT; + uReadPos = uSizeFile-uBackRead ; + + uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? + (BUFREADCOMMENT+4) : (uSizeFile-uReadPos); + if (fseek(fin,uReadPos,SEEK_SET)!=0) + break; + + if (fread(buf,(uInt)uReadSize,1,fin)!=1) + break; + + for (i=(int)uReadSize-3; (i--)>0;) + if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && + ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) + { + uPosFound = uReadPos+i; + break; + } + + if (uPosFound!=0) + break; + } + TRYFREE(buf); + return uPosFound; +} + +/* + Open a Zip file. path contain the full pathname (by example, + on a Windows NT computer "c:\\test\\zlib109.zip" or on an Unix computer + "zlib/zlib109.zip". + If the zipfile cannot be opened (file don't exist or in not valid), the + return value is NULL. + Else, the return value is a unzFile Handle, usable with other function + of this unzip package. +*/ +extern unzFile ZEXPORT unzOpen (path) + const char *path; +{ + unz_s us; + unz_s *s; + uLong central_pos,uL; + FILE * fin ; + + uLong number_disk; /* number of the current dist, used for + spaning ZIP, unsupported, always 0*/ + uLong number_disk_with_CD; /* number the the disk with central dir, used + for spaning ZIP, unsupported, always 0*/ + uLong number_entry_CD; /* total number of entries in + the central dir + (same than number_entry on nospan) */ + + int err=UNZ_OK; + + if (unz_copyright[0]!=' ') + return NULL; + + fin=fopen(path,"rb"); + if (fin==NULL) + return NULL; + + central_pos = unzlocal_SearchCentralDir(fin); + if (central_pos==0) + err=UNZ_ERRNO; + + if (fseek(fin,central_pos,SEEK_SET)!=0) + err=UNZ_ERRNO; + + /* the signature, already checked */ + if (unzlocal_getLong(fin,&uL)!=UNZ_OK) + err=UNZ_ERRNO; + + /* number of this disk */ + if (unzlocal_getShort(fin,&number_disk)!=UNZ_OK) + err=UNZ_ERRNO; + + /* number of the disk with the start of the central directory */ + if (unzlocal_getShort(fin,&number_disk_with_CD)!=UNZ_OK) + err=UNZ_ERRNO; + + /* total number of entries in the central dir on this disk */ + if (unzlocal_getShort(fin,&us.gi.number_entry)!=UNZ_OK) + err=UNZ_ERRNO; + + /* total number of entries in the central dir */ + if (unzlocal_getShort(fin,&number_entry_CD)!=UNZ_OK) + err=UNZ_ERRNO; + + if ((number_entry_CD!=us.gi.number_entry) || + (number_disk_with_CD!=0) || + (number_disk!=0)) + err=UNZ_BADZIPFILE; + + /* size of the central directory */ + if (unzlocal_getLong(fin,&us.size_central_dir)!=UNZ_OK) + err=UNZ_ERRNO; + + /* offset of start of central directory with respect to the + starting disk number */ + if (unzlocal_getLong(fin,&us.offset_central_dir)!=UNZ_OK) + err=UNZ_ERRNO; + + /* zipfile comment length */ + if (unzlocal_getShort(fin,&us.gi.size_comment)!=UNZ_OK) + err=UNZ_ERRNO; + + if ((central_pospfile_in_zip_read!=NULL) + unzCloseCurrentFile(file); + + fclose(s->file); + TRYFREE(s); + return UNZ_OK; +} + + +/* + Write info about the ZipFile in the *pglobal_info structure. + No preparation of the structure is needed + return UNZ_OK if there is no problem. */ +extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info) + unzFile file; + unz_global_info *pglobal_info; +{ + unz_s* s; + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz_s*)file; + *pglobal_info=s->gi; + return UNZ_OK; +} + + +/* + Translate date/time from Dos format to tm_unz (readable more easilty) +*/ +local void unzlocal_DosDateToTmuDate (ulDosDate, ptm) + uLong ulDosDate; + tm_unz* ptm; +{ + uLong uDate; + uDate = (uLong)(ulDosDate>>16); + ptm->tm_mday = (uInt)(uDate&0x1f) ; + ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1) ; + ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ; + + ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800); + ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ; + ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ; +} + +/* + Get Info about the current file in the zipfile, with internal only info +*/ +local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file, + unz_file_info *pfile_info, + unz_file_info_internal + *pfile_info_internal, + char *szFileName, + uLong fileNameBufferSize, + void *extraField, + uLong extraFieldBufferSize, + char *szComment, + uLong commentBufferSize)); + +local int unzlocal_GetCurrentFileInfoInternal (file, + pfile_info, + pfile_info_internal, + szFileName, fileNameBufferSize, + extraField, extraFieldBufferSize, + szComment, commentBufferSize) + unzFile file; + unz_file_info *pfile_info; + unz_file_info_internal *pfile_info_internal; + char *szFileName; + uLong fileNameBufferSize; + void *extraField; + uLong extraFieldBufferSize; + char *szComment; + uLong commentBufferSize; +{ + unz_s* s; + unz_file_info file_info; + unz_file_info_internal file_info_internal; + int err=UNZ_OK; + uLong uMagic; + long lSeek=0; + + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz_s*)file; + if (fseek(s->file,s->pos_in_central_dir+s->byte_before_the_zipfile,SEEK_SET)!=0) + err=UNZ_ERRNO; + + + /* we check the magic */ + if (err==UNZ_OK) + if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK) + err=UNZ_ERRNO; + else if (uMagic!=0x02014b50) + err=UNZ_BADZIPFILE; + + if (unzlocal_getShort(s->file,&file_info.version) != UNZ_OK) + err=UNZ_ERRNO; + + if (unzlocal_getShort(s->file,&file_info.version_needed) != UNZ_OK) + err=UNZ_ERRNO; + + if (unzlocal_getShort(s->file,&file_info.flag) != UNZ_OK) + err=UNZ_ERRNO; + + if (unzlocal_getShort(s->file,&file_info.compression_method) != UNZ_OK) + err=UNZ_ERRNO; + + if (unzlocal_getLong(s->file,&file_info.dosDate) != UNZ_OK) + err=UNZ_ERRNO; + + unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date); + + if (unzlocal_getLong(s->file,&file_info.crc) != UNZ_OK) + err=UNZ_ERRNO; + + if (unzlocal_getLong(s->file,&file_info.compressed_size) != UNZ_OK) + err=UNZ_ERRNO; + + if (unzlocal_getLong(s->file,&file_info.uncompressed_size) != UNZ_OK) + err=UNZ_ERRNO; + + if (unzlocal_getShort(s->file,&file_info.size_filename) != UNZ_OK) + err=UNZ_ERRNO; + + if (unzlocal_getShort(s->file,&file_info.size_file_extra) != UNZ_OK) + err=UNZ_ERRNO; + + if (unzlocal_getShort(s->file,&file_info.size_file_comment) != UNZ_OK) + err=UNZ_ERRNO; + + if (unzlocal_getShort(s->file,&file_info.disk_num_start) != UNZ_OK) + err=UNZ_ERRNO; + + if (unzlocal_getShort(s->file,&file_info.internal_fa) != UNZ_OK) + err=UNZ_ERRNO; + + if (unzlocal_getLong(s->file,&file_info.external_fa) != UNZ_OK) + err=UNZ_ERRNO; + + if (unzlocal_getLong(s->file,&file_info_internal.offset_curfile) != UNZ_OK) + err=UNZ_ERRNO; + + lSeek+=file_info.size_filename; + if ((err==UNZ_OK) && (szFileName!=NULL)) + { + uLong uSizeRead ; + if (file_info.size_filename0) && (fileNameBufferSize>0)) + if (fread(szFileName,(uInt)uSizeRead,1,s->file)!=1) + err=UNZ_ERRNO; + lSeek -= uSizeRead; + } + + + if ((err==UNZ_OK) && (extraField!=NULL)) + { + uLong uSizeRead ; + if (file_info.size_file_extrafile,lSeek,SEEK_CUR)==0) + lSeek=0; + else + err=UNZ_ERRNO; + if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0)) + if (fread(extraField,(uInt)uSizeRead,1,s->file)!=1) + err=UNZ_ERRNO; + lSeek += file_info.size_file_extra - uSizeRead; + } + else + lSeek+=file_info.size_file_extra; + + + if ((err==UNZ_OK) && (szComment!=NULL)) + { + uLong uSizeRead ; + if (file_info.size_file_commentfile,lSeek,SEEK_CUR)==0) + lSeek=0; + else + err=UNZ_ERRNO; + if ((file_info.size_file_comment>0) && (commentBufferSize>0)) + if (fread(szComment,(uInt)uSizeRead,1,s->file)!=1) + err=UNZ_ERRNO; + lSeek+=file_info.size_file_comment - uSizeRead; + } + else + lSeek+=file_info.size_file_comment; + + if ((err==UNZ_OK) && (pfile_info!=NULL)) + *pfile_info=file_info; + + if ((err==UNZ_OK) && (pfile_info_internal!=NULL)) + *pfile_info_internal=file_info_internal; + + return err; +} + + + +/* + Write info about the ZipFile in the *pglobal_info structure. + No preparation of the structure is needed + return UNZ_OK if there is no problem. +*/ +extern int ZEXPORT unzGetCurrentFileInfo (file, + pfile_info, + szFileName, fileNameBufferSize, + extraField, extraFieldBufferSize, + szComment, commentBufferSize) + unzFile file; + unz_file_info *pfile_info; + char *szFileName; + uLong fileNameBufferSize; + void *extraField; + uLong extraFieldBufferSize; + char *szComment; + uLong commentBufferSize; +{ + return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL, + szFileName,fileNameBufferSize, + extraField,extraFieldBufferSize, + szComment,commentBufferSize); +} + +/* + Set the current file of the zipfile to the first file. + return UNZ_OK if there is no problem +*/ +extern int ZEXPORT unzGoToFirstFile (file) + unzFile file; +{ + int err=UNZ_OK; + unz_s* s; + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz_s*)file; + s->pos_in_central_dir=s->offset_central_dir; + s->num_file=0; + err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info, + &s->cur_file_info_internal, + NULL,0,NULL,0,NULL,0); + s->current_file_ok = (err == UNZ_OK); + return err; +} + + +/* + Set the current file of the zipfile to the next file. + return UNZ_OK if there is no problem + return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest. +*/ +extern int ZEXPORT unzGoToNextFile (file) + unzFile file; +{ + unz_s* s; + int err; + + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz_s*)file; + if (!s->current_file_ok) + return UNZ_END_OF_LIST_OF_FILE; + if (s->num_file+1==s->gi.number_entry) + return UNZ_END_OF_LIST_OF_FILE; + + s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename + + s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ; + s->num_file++; + err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info, + &s->cur_file_info_internal, + NULL,0,NULL,0,NULL,0); + s->current_file_ok = (err == UNZ_OK); + return err; +} + + +/* + Try locate the file szFileName in the zipfile. + For the iCaseSensitivity signification, see unzipStringFileNameCompare + + return value : + UNZ_OK if the file is found. It becomes the current file. + UNZ_END_OF_LIST_OF_FILE if the file is not found +*/ +extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity) + unzFile file; + const char *szFileName; + int iCaseSensitivity; +{ + unz_s* s; + int err; + + + uLong num_fileSaved; + uLong pos_in_central_dirSaved; + + + if (file==NULL) + return UNZ_PARAMERROR; + + if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP) + return UNZ_PARAMERROR; + + s=(unz_s*)file; + if (!s->current_file_ok) + return UNZ_END_OF_LIST_OF_FILE; + + num_fileSaved = s->num_file; + pos_in_central_dirSaved = s->pos_in_central_dir; + + err = unzGoToFirstFile(file); + + while (err == UNZ_OK) + { + char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1]; + unzGetCurrentFileInfo(file,NULL, + szCurrentFileName,sizeof(szCurrentFileName)-1, + NULL,0,NULL,0); + if (unzStringFileNameCompare(szCurrentFileName, + szFileName,iCaseSensitivity)==0) + return UNZ_OK; + err = unzGoToNextFile(file); + } + + s->num_file = num_fileSaved ; + s->pos_in_central_dir = pos_in_central_dirSaved ; + return err; +} + + +/* + Read the local header of the current zipfile + Check the coherency of the local header and info in the end of central + directory about this file + store in *piSizeVar the size of extra info in local header + (filename and size of extra field data) +*/ +local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar, + poffset_local_extrafield, + psize_local_extrafield) + unz_s* s; + uInt* piSizeVar; + uLong *poffset_local_extrafield; + uInt *psize_local_extrafield; +{ + uLong uMagic,uData,uFlags; + uLong size_filename; + uLong size_extra_field; + int err=UNZ_OK; + + *piSizeVar = 0; + *poffset_local_extrafield = 0; + *psize_local_extrafield = 0; + + if (fseek(s->file,s->cur_file_info_internal.offset_curfile + + s->byte_before_the_zipfile,SEEK_SET)!=0) + return UNZ_ERRNO; + + + if (err==UNZ_OK) + if (unzlocal_getLong(s->file,&uMagic) != UNZ_OK) + err=UNZ_ERRNO; + else if (uMagic!=0x04034b50) + err=UNZ_BADZIPFILE; + + if (unzlocal_getShort(s->file,&uData) != UNZ_OK) + err=UNZ_ERRNO; +/* + else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion)) + err=UNZ_BADZIPFILE; +*/ + if (unzlocal_getShort(s->file,&uFlags) != UNZ_OK) + err=UNZ_ERRNO; + + if (unzlocal_getShort(s->file,&uData) != UNZ_OK) + err=UNZ_ERRNO; + else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method)) + err=UNZ_BADZIPFILE; + + if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) && + (s->cur_file_info.compression_method!=Z_DEFLATED)) + err=UNZ_BADZIPFILE; + + if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* date/time */ + err=UNZ_ERRNO; + + if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* crc */ + err=UNZ_ERRNO; + else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) && + ((uFlags & 8)==0)) + err=UNZ_BADZIPFILE; + + if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size compr */ + err=UNZ_ERRNO; + else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) && + ((uFlags & 8)==0)) + err=UNZ_BADZIPFILE; + + if (unzlocal_getLong(s->file,&uData) != UNZ_OK) /* size uncompr */ + err=UNZ_ERRNO; + else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && + ((uFlags & 8)==0)) + err=UNZ_BADZIPFILE; + + + if (unzlocal_getShort(s->file,&size_filename) != UNZ_OK) + err=UNZ_ERRNO; + else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename)) + err=UNZ_BADZIPFILE; + + *piSizeVar += (uInt)size_filename; + + if (unzlocal_getShort(s->file,&size_extra_field) != UNZ_OK) + err=UNZ_ERRNO; + *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile + + SIZEZIPLOCALHEADER + size_filename; + *psize_local_extrafield = (uInt)size_extra_field; + + *piSizeVar += (uInt)size_extra_field; + + return err; +} + +/* + Open for reading data the current file in the zipfile. + If there is no error and the file is opened, the return value is UNZ_OK. +*/ +extern int ZEXPORT unzOpenCurrentFile (file) + unzFile file; +{ + int err=UNZ_OK; + int Store; + uInt iSizeVar; + unz_s* s; + file_in_zip_read_info_s* pfile_in_zip_read_info; + uLong offset_local_extrafield; /* offset of the local extra field */ + uInt size_local_extrafield; /* size of the local extra field */ + + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz_s*)file; + if (!s->current_file_ok) + return UNZ_PARAMERROR; + + if (s->pfile_in_zip_read != NULL) + unzCloseCurrentFile(file); + + if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar, + &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK) + return UNZ_BADZIPFILE; + + pfile_in_zip_read_info = (file_in_zip_read_info_s*) + ALLOC(sizeof(file_in_zip_read_info_s)); + if (pfile_in_zip_read_info==NULL) + return UNZ_INTERNALERROR; + + pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE); + pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield; + pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield; + pfile_in_zip_read_info->pos_local_extrafield=0; + + if (pfile_in_zip_read_info->read_buffer==NULL) + { + TRYFREE(pfile_in_zip_read_info); + return UNZ_INTERNALERROR; + } + + pfile_in_zip_read_info->stream_initialised=0; + + if ((s->cur_file_info.compression_method!=0) && + (s->cur_file_info.compression_method!=Z_DEFLATED)) + err=UNZ_BADZIPFILE; + Store = s->cur_file_info.compression_method==0; + + pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc; + pfile_in_zip_read_info->crc32=0; + pfile_in_zip_read_info->compression_method = + s->cur_file_info.compression_method; + pfile_in_zip_read_info->file=s->file; + pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile; + + pfile_in_zip_read_info->stream.total_out = 0; + + if (!Store) + { + pfile_in_zip_read_info->stream.zalloc = (alloc_func)0; + pfile_in_zip_read_info->stream.zfree = (free_func)0; + pfile_in_zip_read_info->stream.opaque = (voidpf)0; + + err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS); + if (err == Z_OK) + pfile_in_zip_read_info->stream_initialised=1; + /* windowBits is passed < 0 to tell that there is no zlib header. + * Note that in this case inflate *requires* an extra "dummy" byte + * after the compressed stream in order to complete decompression and + * return Z_STREAM_END. + * In unzip, i don't wait absolutely Z_STREAM_END because I known the + * size of both compressed and uncompressed data + */ + } + pfile_in_zip_read_info->rest_read_compressed = + s->cur_file_info.compressed_size ; + pfile_in_zip_read_info->rest_read_uncompressed = + s->cur_file_info.uncompressed_size ; + + + pfile_in_zip_read_info->pos_in_zipfile = + s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + + iSizeVar; + + pfile_in_zip_read_info->stream.avail_in = (uInt)0; + + + s->pfile_in_zip_read = pfile_in_zip_read_info; + return UNZ_OK; +} + + +/* + Read bytes from the current file. + buf contain buffer where data must be copied + len the size of buf. + + return the number of byte copied if somes bytes are copied + return 0 if the end of file was reached + return <0 with error code if there is an error + (UNZ_ERRNO for IO error, or zLib error for uncompress error) +*/ +extern int ZEXPORT unzReadCurrentFile (file, buf, len) + unzFile file; + voidp buf; + unsigned len; +{ + int err=UNZ_OK; + uInt iRead = 0; + unz_s* s; + file_in_zip_read_info_s* pfile_in_zip_read_info; + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz_s*)file; + pfile_in_zip_read_info=s->pfile_in_zip_read; + + if (pfile_in_zip_read_info==NULL) + return UNZ_PARAMERROR; + + + if ((pfile_in_zip_read_info->read_buffer == NULL)) + return UNZ_END_OF_LIST_OF_FILE; + if (len==0) + return 0; + + pfile_in_zip_read_info->stream.next_out = (Bytef*)buf; + + pfile_in_zip_read_info->stream.avail_out = (uInt)len; + + if (len>pfile_in_zip_read_info->rest_read_uncompressed) + pfile_in_zip_read_info->stream.avail_out = + (uInt)pfile_in_zip_read_info->rest_read_uncompressed; + + while (pfile_in_zip_read_info->stream.avail_out>0) + { + if ((pfile_in_zip_read_info->stream.avail_in==0) && + (pfile_in_zip_read_info->rest_read_compressed>0)) + { + uInt uReadThis = UNZ_BUFSIZE; + if (pfile_in_zip_read_info->rest_read_compressedrest_read_compressed; + if (uReadThis == 0) + return UNZ_EOF; + if (fseek(pfile_in_zip_read_info->file, + pfile_in_zip_read_info->pos_in_zipfile + + pfile_in_zip_read_info->byte_before_the_zipfile,SEEK_SET)!=0) + return UNZ_ERRNO; + if (fread(pfile_in_zip_read_info->read_buffer,uReadThis,1, + pfile_in_zip_read_info->file)!=1) + return UNZ_ERRNO; + pfile_in_zip_read_info->pos_in_zipfile += uReadThis; + + pfile_in_zip_read_info->rest_read_compressed-=uReadThis; + + pfile_in_zip_read_info->stream.next_in = + (Bytef*)pfile_in_zip_read_info->read_buffer; + pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis; + } + + if (pfile_in_zip_read_info->compression_method==0) + { + uInt uDoCopy,i ; + if (pfile_in_zip_read_info->stream.avail_out < + pfile_in_zip_read_info->stream.avail_in) + uDoCopy = pfile_in_zip_read_info->stream.avail_out ; + else + uDoCopy = pfile_in_zip_read_info->stream.avail_in ; + + for (i=0;istream.next_out+i) = + *(pfile_in_zip_read_info->stream.next_in+i); + + pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32, + pfile_in_zip_read_info->stream.next_out, + uDoCopy); + pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy; + pfile_in_zip_read_info->stream.avail_in -= uDoCopy; + pfile_in_zip_read_info->stream.avail_out -= uDoCopy; + pfile_in_zip_read_info->stream.next_out += uDoCopy; + pfile_in_zip_read_info->stream.next_in += uDoCopy; + pfile_in_zip_read_info->stream.total_out += uDoCopy; + iRead += uDoCopy; + } + else + { + uLong uTotalOutBefore,uTotalOutAfter; + const Bytef *bufBefore; + uLong uOutThis; + int flush=Z_SYNC_FLUSH; + + uTotalOutBefore = pfile_in_zip_read_info->stream.total_out; + bufBefore = pfile_in_zip_read_info->stream.next_out; + + /* + if ((pfile_in_zip_read_info->rest_read_uncompressed == + pfile_in_zip_read_info->stream.avail_out) && + (pfile_in_zip_read_info->rest_read_compressed == 0)) + flush = Z_FINISH; + */ + err=inflate(&pfile_in_zip_read_info->stream,flush); + + uTotalOutAfter = pfile_in_zip_read_info->stream.total_out; + uOutThis = uTotalOutAfter-uTotalOutBefore; + + pfile_in_zip_read_info->crc32 = + crc32(pfile_in_zip_read_info->crc32,bufBefore, + (uInt)(uOutThis)); + + pfile_in_zip_read_info->rest_read_uncompressed -= + uOutThis; + + iRead += (uInt)(uTotalOutAfter - uTotalOutBefore); + + if (err==Z_STREAM_END) + return (iRead==0) ? UNZ_EOF : iRead; + if (err!=Z_OK) + break; + } + } + + if (err==Z_OK) + return iRead; + return err; +} + + +/* + Give the current position in uncompressed data +*/ +extern z_off_t ZEXPORT unztell (file) + unzFile file; +{ + unz_s* s; + file_in_zip_read_info_s* pfile_in_zip_read_info; + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz_s*)file; + pfile_in_zip_read_info=s->pfile_in_zip_read; + + if (pfile_in_zip_read_info==NULL) + return UNZ_PARAMERROR; + + return (z_off_t)pfile_in_zip_read_info->stream.total_out; +} + + +/* + return 1 if the end of file was reached, 0 elsewhere +*/ +extern int ZEXPORT unzeof (file) + unzFile file; +{ + unz_s* s; + file_in_zip_read_info_s* pfile_in_zip_read_info; + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz_s*)file; + pfile_in_zip_read_info=s->pfile_in_zip_read; + + if (pfile_in_zip_read_info==NULL) + return UNZ_PARAMERROR; + + if (pfile_in_zip_read_info->rest_read_uncompressed == 0) + return 1; + else + return 0; +} + + + +/* + Read extra field from the current file (opened by unzOpenCurrentFile) + This is the local-header version of the extra field (sometimes, there is + more info in the local-header version than in the central-header) + + if buf==NULL, it return the size of the local extra field that can be read + + if buf!=NULL, len is the size of the buffer, the extra header is copied in + buf. + the return value is the number of bytes copied in buf, or (if <0) + the error code +*/ +extern int ZEXPORT unzGetLocalExtrafield (file,buf,len) + unzFile file; + voidp buf; + unsigned len; +{ + unz_s* s; + file_in_zip_read_info_s* pfile_in_zip_read_info; + uInt read_now; + uLong size_to_read; + + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz_s*)file; + pfile_in_zip_read_info=s->pfile_in_zip_read; + + if (pfile_in_zip_read_info==NULL) + return UNZ_PARAMERROR; + + size_to_read = (pfile_in_zip_read_info->size_local_extrafield - + pfile_in_zip_read_info->pos_local_extrafield); + + if (buf==NULL) + return (int)size_to_read; + + if (len>size_to_read) + read_now = (uInt)size_to_read; + else + read_now = (uInt)len ; + + if (read_now==0) + return 0; + + if (fseek(pfile_in_zip_read_info->file, + pfile_in_zip_read_info->offset_local_extrafield + + pfile_in_zip_read_info->pos_local_extrafield,SEEK_SET)!=0) + return UNZ_ERRNO; + + if (fread(buf,(uInt)size_to_read,1,pfile_in_zip_read_info->file)!=1) + return UNZ_ERRNO; + + return (int)read_now; +} + +/* + Close the file in zip opened with unzipOpenCurrentFile + Return UNZ_CRCERROR if all the file was read but the CRC is not good +*/ +extern int ZEXPORT unzCloseCurrentFile (file) + unzFile file; +{ + int err=UNZ_OK; + + unz_s* s; + file_in_zip_read_info_s* pfile_in_zip_read_info; + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz_s*)file; + pfile_in_zip_read_info=s->pfile_in_zip_read; + + if (pfile_in_zip_read_info==NULL) + return UNZ_PARAMERROR; + + + if (pfile_in_zip_read_info->rest_read_uncompressed == 0) + { + if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait) + err=UNZ_CRCERROR; + } + + + TRYFREE(pfile_in_zip_read_info->read_buffer); + pfile_in_zip_read_info->read_buffer = NULL; + if (pfile_in_zip_read_info->stream_initialised) + inflateEnd(&pfile_in_zip_read_info->stream); + + pfile_in_zip_read_info->stream_initialised = 0; + TRYFREE(pfile_in_zip_read_info); + + s->pfile_in_zip_read=NULL; + + return err; +} + + +/* + Get the global comment string of the ZipFile, in the szComment buffer. + uSizeBuf is the size of the szComment buffer. + return the number of byte copied or an error code <0 +*/ +extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf) + unzFile file; + char *szComment; + uLong uSizeBuf; +{ + int err=UNZ_OK; + unz_s* s; + uLong uReadThis ; + if (file==NULL) + return UNZ_PARAMERROR; + s=(unz_s*)file; + + uReadThis = uSizeBuf; + if (uReadThis>s->gi.size_comment) + uReadThis = s->gi.size_comment; + + if (fseek(s->file,s->central_pos+22,SEEK_SET)!=0) + return UNZ_ERRNO; + + if (uReadThis>0) + { + *szComment='\0'; + if (fread(szComment,(uInt)uReadThis,1,s->file)!=1) + return UNZ_ERRNO; + } + + if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment)) + *(szComment+s->gi.size_comment)='\0'; + return (int)uReadThis; +} diff --git a/tgeb/unzip.h b/tgeb/unzip.h new file mode 100644 index 0000000..76692cb --- /dev/null +++ b/tgeb/unzip.h @@ -0,0 +1,275 @@ +/* unzip.h -- IO for uncompress .zip files using zlib + Version 0.15 beta, Mar 19th, 1998, + + Copyright (C) 1998 Gilles Vollant + + This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g + WinZip, InfoZip tools and compatible. + Encryption and multi volume ZipFile (span) are not supported. + Old compressions used by old PKZip 1.x are not supported + + THIS IS AN ALPHA VERSION. AT THIS STAGE OF DEVELOPPEMENT, SOMES API OR STRUCTURE + CAN CHANGE IN FUTURE VERSION !! + I WAIT FEEDBACK at mail info@winimage.com + Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution + + Condition of use and distribution are the same than zlib : + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + +*/ +/* for more info about .ZIP format, see + ftp://ftp.cdrom.com/pub/infozip/doc/appnote-970311-iz.zip + PkWare has also a specification at : + ftp://ftp.pkware.com/probdesc.zip */ + +#ifndef _unz_H +#define _unz_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _ZLIB_H +#include "zlib.h" +#endif + +#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP) +/* like the STRICT of WIN32, we define a pointer that cannot be converted + from (void*) without cast */ +typedef struct TagunzFile__ { int unused; } unzFile__; +typedef unzFile__ *unzFile; +#else +typedef voidp unzFile; +#endif + + +#define UNZ_OK (0) +#define UNZ_END_OF_LIST_OF_FILE (-100) +#define UNZ_ERRNO (Z_ERRNO) +#define UNZ_EOF (0) +#define UNZ_PARAMERROR (-102) +#define UNZ_BADZIPFILE (-103) +#define UNZ_INTERNALERROR (-104) +#define UNZ_CRCERROR (-105) + +/* tm_unz contain date/time info */ +typedef struct tm_unz_s +{ + uInt tm_sec; /* seconds after the minute - [0,59] */ + uInt tm_min; /* minutes after the hour - [0,59] */ + uInt tm_hour; /* hours since midnight - [0,23] */ + uInt tm_mday; /* day of the month - [1,31] */ + uInt tm_mon; /* months since January - [0,11] */ + uInt tm_year; /* years - [1980..2044] */ +} tm_unz; + +/* unz_global_info structure contain global data about the ZIPfile + These data comes from the end of central dir */ +typedef struct unz_global_info_s +{ + uLong number_entry; /* total number of entries in + the central dir on this disk */ + uLong size_comment; /* size of the global comment of the zipfile */ +} unz_global_info; + + +/* unz_file_info contain information about a file in the zipfile */ +typedef struct unz_file_info_s +{ + uLong version; /* version made by 2 bytes */ + uLong version_needed; /* version needed to extract 2 bytes */ + uLong flag; /* general purpose bit flag 2 bytes */ + uLong compression_method; /* compression method 2 bytes */ + uLong dosDate; /* last mod file date in Dos fmt 4 bytes */ + uLong crc; /* crc-32 4 bytes */ + uLong compressed_size; /* compressed size 4 bytes */ + uLong uncompressed_size; /* uncompressed size 4 bytes */ + uLong size_filename; /* filename length 2 bytes */ + uLong size_file_extra; /* extra field length 2 bytes */ + uLong size_file_comment; /* file comment length 2 bytes */ + + uLong disk_num_start; /* disk number start 2 bytes */ + uLong internal_fa; /* internal file attributes 2 bytes */ + uLong external_fa; /* external file attributes 4 bytes */ + + tm_unz tmu_date; +} unz_file_info; + +extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1, + const char* fileName2, + int iCaseSensitivity)); +/* + Compare two filename (fileName1,fileName2). + If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp) + If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi + or strcasecmp) + If iCaseSenisivity = 0, case sensitivity is defaut of your operating system + (like 1 on Unix, 2 on Windows) +*/ + + +extern unzFile ZEXPORT unzOpen OF((const char *path)); +/* + Open a Zip file. path contain the full pathname (by example, + on a Windows NT computer "c:\\zlib\\zlib111.zip" or on an Unix computer + "zlib/zlib111.zip". + If the zipfile cannot be opened (file don't exist or in not valid), the + return value is NULL. + Else, the return value is a unzFile Handle, usable with other function + of this unzip package. +*/ + +extern int ZEXPORT unzClose OF((unzFile file)); +/* + Close a ZipFile opened with unzipOpen. + If there is files inside the .Zip opened with unzOpenCurrentFile (see later), + these files MUST be closed with unzipCloseCurrentFile before call unzipClose. + return UNZ_OK if there is no problem. */ + +extern int ZEXPORT unzGetGlobalInfo OF((unzFile file, + unz_global_info *pglobal_info)); +/* + Write info about the ZipFile in the *pglobal_info structure. + No preparation of the structure is needed + return UNZ_OK if there is no problem. */ + + +extern int ZEXPORT unzGetGlobalComment OF((unzFile file, + char *szComment, + uLong uSizeBuf)); +/* + Get the global comment string of the ZipFile, in the szComment buffer. + uSizeBuf is the size of the szComment buffer. + return the number of byte copied or an error code <0 +*/ + + +/***************************************************************************/ +/* Unzip package allow you browse the directory of the zipfile */ + +extern int ZEXPORT unzGoToFirstFile OF((unzFile file)); +/* + Set the current file of the zipfile to the first file. + return UNZ_OK if there is no problem +*/ + +extern int ZEXPORT unzGoToNextFile OF((unzFile file)); +/* + Set the current file of the zipfile to the next file. + return UNZ_OK if there is no problem + return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest. +*/ + +extern int ZEXPORT unzLocateFile OF((unzFile file, + const char *szFileName, + int iCaseSensitivity)); +/* + Try locate the file szFileName in the zipfile. + For the iCaseSensitivity signification, see unzStringFileNameCompare + + return value : + UNZ_OK if the file is found. It becomes the current file. + UNZ_END_OF_LIST_OF_FILE if the file is not found +*/ + + +extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file, + unz_file_info *pfile_info, + char *szFileName, + uLong fileNameBufferSize, + void *extraField, + uLong extraFieldBufferSize, + char *szComment, + uLong commentBufferSize)); +/* + Get Info about the current file + if pfile_info!=NULL, the *pfile_info structure will contain somes info about + the current file + if szFileName!=NULL, the filemane string will be copied in szFileName + (fileNameBufferSize is the size of the buffer) + if extraField!=NULL, the extra field information will be copied in extraField + (extraFieldBufferSize is the size of the buffer). + This is the Central-header version of the extra field + if szComment!=NULL, the comment string of the file will be copied in szComment + (commentBufferSize is the size of the buffer) +*/ + +/***************************************************************************/ +/* for reading the content of the current zipfile, you can open it, read data + from it, and close it (you can close it before reading all the file) + */ + +extern int ZEXPORT unzOpenCurrentFile OF((unzFile file)); +/* + Open for reading data the current file in the zipfile. + If there is no error, the return value is UNZ_OK. +*/ + +extern int ZEXPORT unzCloseCurrentFile OF((unzFile file)); +/* + Close the file in zip opened with unzOpenCurrentFile + Return UNZ_CRCERROR if all the file was read but the CRC is not good +*/ + + +extern int ZEXPORT unzReadCurrentFile OF((unzFile file, + voidp buf, + unsigned len)); +/* + Read bytes from the current file (opened by unzOpenCurrentFile) + buf contain buffer where data must be copied + len the size of buf. + + return the number of byte copied if somes bytes are copied + return 0 if the end of file was reached + return <0 with error code if there is an error + (UNZ_ERRNO for IO error, or zLib error for uncompress error) +*/ + +extern z_off_t ZEXPORT unztell OF((unzFile file)); +/* + Give the current position in uncompressed data +*/ + +extern int ZEXPORT unzeof OF((unzFile file)); +/* + return 1 if the end of file was reached, 0 elsewhere +*/ + +extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file, + voidp buf, + unsigned len)); +/* + Read extra field from the current file (opened by unzOpenCurrentFile) + This is the local-header version of the extra field (sometimes, there is + more info in the local-header version than in the central-header) + + if buf==NULL, it return the size of the local extra field + + if buf!=NULL, len is the size of the buffer, the extra header is copied in + buf. + the return value is the number of bytes copied in buf, or (if <0) + the error code +*/ + +#ifdef __cplusplus +} +#endif + +#endif /* _unz_H */ diff --git a/tgeb/update.c b/tgeb/update.c new file mode 100644 index 0000000..307fb75 --- /dev/null +++ b/tgeb/update.c @@ -0,0 +1,129 @@ +/* $Id$ */ +/* + * Copyright (c) 2004 demon + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "unzip.h" +#include "tgebup.h" + +#define DATFILE "/tmp/tarife.zip" + +const char *TGebURL = "www.billiger-telefonieren.de"; +const char *TGebGET = "GET /downloads/tgeb/tarife_%.4i%.2i%.2i.zip HTTP/1.0\n\n"; + +static void unzip(void); + +void +tgeb_update(struct tm * tm) +{ + struct hostent *he; + struct sockaddr_in sin; + int sockfd; + char *get; + char *buf; + FILE *fd; + char *file; + int filelen; + int offset = 0; + + if (!(he = gethostbyname(TGebURL))) + err(1, "gethostbyname"); + + if ((sockfd = socket(AF_INET, SOCK_STREAM, NULL)) == -1) + err(1, "socket"); + memset(&sin, '\0', sizeof(struct sockaddr_in)); + sin.sin_family = AF_INET; + sin.sin_port = htons(80); + sin.sin_addr = *((struct in_addr *)he->h_addr); + + if ((connect(sockfd, (struct sockaddr *)&sin, + sizeof(struct sockaddr))) == -1) + err(1, "connect"); + + if (!(get = malloc(sizeof(char) * strlen(TGebGET)))) + err(1, "malloc"); + sprintf(get, TGebGET, tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday); + if ((send(sockfd, get, strlen(get), NULL)) == -1) + err(1, "send"); + free(get); + + if (!(buf = malloc(sizeof(char) * 1024))) + err(1, "malloc"); + + for(;;) { + int block; + if ((block = recv(sockfd, &buf[offset], 1024, NULL)) == -1) + err(1, "recv"); + if (block == 0) + break; + offset += block; + if (!(buf = realloc(buf, offset + 1024))) + err(1, "malloc"); + } + close(sockfd); + file = strstr(buf, "\r\n\r\n") + 4; + filelen = offset + buf - file; + + if (!(fd = fopen(DATFILE, "wb"))) + err(1, "fopen %s", DATFILE); + fwrite(file, 1, filelen, fd); + fclose(fd); + free(buf); + unzip(); + return; +} + +void +unzip(void) +{ + FILE *fd; + unzFile *unzfd; + unz_global_info gi; + unz_file_info fi; + char FileName[256]; + char buf[1024]; + int i, len; + + if (!(unzfd = unzOpen(DATFILE))) + errx(1, "unzOpen %s", DATFILE); + unzGetGlobalInfo(unzfd, &gi); + for (i = 0; i < gi.number_entry; i++) { + unzGetCurrentFileInfo(unzfd, &fi, FileName, sizeof(FileName), + NULL, 0, NULL, 0); + unzOpenCurrentFile(unzfd); + if (!(fd = fopen(FileName, "wb"))) + err(1, "fopen %s", FileName); + while((len = unzReadCurrentFile(unzfd, &buf, 1024))) { + fwrite(buf, len, 1, fd); + } + fclose(fd); + unzGoToNextFile(unzfd); + } + unzClose(unzfd); + unlink(DATFILE); + return; +} -- cgit v1.2.3