OSDN Git Service

* src/util.c (rename): no use on mingw32 (have no link(2)).
[lha/lha.git] / src / util.c
1 /* ------------------------------------------------------------------------ */
2 /* LHa for UNIX                                                                                                                         */
3 /*                              util.c -- LHarc Util                                                                            */
4 /*                                                                                                                                                      */
5 /*              Modified                        Nobutaka Watazaki                                                       */
6 /*                                                                                                                                                      */
7 /*      Ver. 1.14       Source All chagned                              1995.01.14      N.Watazaki              */
8 /*  Ver. 1.14e  Support for sfx archives                1999.05.28      T.Okamoto       */
9 /* ------------------------------------------------------------------------ */
10 #include "lha.h"
11 /*
12  * util.c - part of LHa for UNIX Feb 26 1992 modified by Masaru Oki Mar  4
13  * 1992 modified by Masaru Oki #ifndef USESTRCASECMP added. Mar 31 1992
14  * modified by Masaru Oki #ifdef NOMEMSET added.
15  */
16 #include <errno.h>
17
18 /* ------------------------------------------------------------------------ */
19 extern unsigned short crc;
20 extern int      quiet;
21 /* ------------------------------------------------------------------------ */
22 long
23 copyfile(f1, f2, size, crc_flg) /* return: size of source file */
24         FILE           *f1;
25         FILE           *f2;
26         long            size;
27         int             crc_flg;/* 0: no crc, 1: crc check, 2: extract, 3:
28                                  * append */
29 {
30         unsigned short  xsize;
31         char           *buf;
32         long            rsize = 0;
33
34         buf = (char *)xmalloc(BUFFERSIZE);
35         crc = 0;
36         if ((crc_flg == 2 || crc_flg) && text_mode)
37                 init_code_cache();
38         while (size > 0) {
39                 /* read */
40                 if (crc_flg == 3 && text_mode) {
41                         xsize = fread_txt(buf, BUFFERSIZE, f1);
42                         if (xsize == 0)
43                                 break;
44                         if (ferror(f1)) {
45                                 fatal_error("file read error\n");
46                         }
47                 }
48                 else {
49                         xsize = (size > BUFFERSIZE) ? BUFFERSIZE : size;
50                         if (fread(buf, 1, xsize, f1) != xsize) {
51                                 fatal_error("file read error\n");
52                         }
53                 }
54                 /* write */
55                 if (f2) {
56                         if (crc_flg == 2 && text_mode) {
57                                 if (fwrite_txt(buf, xsize, f2)) {
58                                         fatal_error("file write error\n");
59                                 }
60                         }
61                         else {
62                                 if (fwrite(buf, 1, xsize, f2) != xsize) {
63                                         fatal_error("file write error\n");
64                                 }
65                         }
66                 }
67                 /* calculate crc */
68                 if (crc_flg) {
69                         calccrc(buf, xsize);
70                 }
71                 rsize += xsize;
72                 if (crc_flg != 3 || !text_mode)
73                         size -= xsize;
74         }
75         free(buf);
76         return rsize;
77 }
78
79 /* ------------------------------------------------------------------------ */
80 int
81 encode_stored_crc(ifp, ofp, size, original_size_var, write_size_var)
82         FILE           *ifp, *ofp;
83         long            size;
84         long           *original_size_var;
85         long           *write_size_var;
86 {
87         int             save_quiet;
88
89         save_quiet = quiet;
90         quiet = 1;
91         size = copyfile(ifp, ofp, size, 3);
92         *original_size_var = *write_size_var = size;
93         quiet = save_quiet;
94         return crc;
95 }
96
97 /* ------------------------------------------------------------------------ */
98 /*      convert path delimit
99         erreturns *filename                                                                                                             */
100 /* ------------------------------------------------------------------------ */
101 unsigned char  *
102 convdelim(path, delim)
103         unsigned char  *path;
104         unsigned char   delim;
105 {
106         unsigned char   c;
107         unsigned char  *p;
108 #ifdef MULTIBYTE_CHAR
109         int             kflg;
110
111         kflg = 0;
112 #endif
113         for (p = path; (c = *p) != 0; p++) {
114 #ifdef MULTIBYTE_CHAR
115                 if (kflg) {
116                         kflg = 0;
117                 }
118                 else if (MULTIBYTE_FIRST_P(c)) {
119                         kflg = 1;
120                 }
121                 else
122 #endif
123                 if (c == '\\' || c == DELIM || c == DELIM2) {
124                         *p = delim;
125                         path = p + 1;
126                 }
127         }
128         return path;
129 }
130
131 /* ------------------------------------------------------------------------ */
132 /* If TRUE, archive file name is msdos SFX file name. */
133 boolean
134 archive_is_msdos_sfx1(name)
135         char           *name;
136 {
137         int             len = strlen(name);
138
139         return ((len >= 4) &&
140                 (strucmp(".COM", name + len - 4) == 0 ||
141                  strucmp(".EXE", name + len - 4) == 0)) ||
142                 ((len >= 2) &&
143                  (strucmp(".x", name + len - 2) == 0));
144 }
145
146 /* ------------------------------------------------------------------------ */
147 /* skip SFX header */
148 boolean
149 skip_msdos_sfx1_code(fp)
150         FILE           *fp;
151 {
152         unsigned char   buffer[MAXSFXCODE];
153         unsigned char  *p, *q;
154         int             n;
155
156         n = fread(buffer, sizeof(char), MAXSFXCODE, fp);
157
158         for (p = buffer + 2, q = buffer + n - /* 5 */ (I_HEADER_LEVEL+1)-2; p < q; p++) {
159                 /* found "-l??-" keyword (as METHOD type string) */
160                 if (p[0] == '-' && p[1] == 'l' && p[4] == '-') {
161                         /* size and checksum validate check */
162                         if ( (p[I_HEADER_LEVEL-2] == 0 || p[I_HEADER_LEVEL-2] == 0)
163                                 && p[I_HEADER_SIZE-2] > 20
164                                 && p[I_HEADER_CHECKSUM-2] == calc_sum(p, p[-2])) {
165                                         fseek(fp, ((p - 2) - buffer) - n, SEEK_CUR);
166                                 return TRUE;
167                         } else if (p[I_HEADER_LEVEL-2] == 2 && p[I_HEADER_SIZE-2] >= 24
168                                            && p[I_ATTRIBUTE-2] == 0x20) {
169                                 fseek(fp, ((p - 2) - buffer) - n, SEEK_CUR);
170                                 return TRUE;
171                         }
172                 }
173         }
174
175         fseek(fp, -n, SEEK_CUR);
176         return FALSE;
177 }
178
179 /*
180  * strdup(3)
181  */
182
183 /* ------------------------------------------------------------------------ */
184 #ifndef HAVE_STRDUP
185 char           *
186 strdup(buf)
187         char           *buf;
188 {
189         char           *p;
190
191         if ((p = (char *) malloc(strlen(buf) + 1)) == NULL)
192                 return NULL;
193         strcpy(p, buf);
194         return p;
195 }
196 #endif
197
198 /*
199  * memmove( char *dst , char *src , size_t cnt )
200  */
201
202 /* ------------------------------------------------------------------------ */
203 #if defined(NOBSTRING) && !defined(__STDC__)
204 void           *
205 memmove(dst, src, cnt)
206         register char  *dst, *src;
207         register int    cnt;
208 {
209         if (dst == src)
210                 return dst;
211         if (src > dst) {
212                 while (--cnt >= 0)
213                         *dst++ = *src++;
214         }
215         else {
216                 dst += cnt;
217                 src += cnt;
218                 while (--cnt >= 0)
219                         *--dst = *--src;
220         }
221         return dst;
222 }
223 #endif
224
225 /*
226  * rename - change the name of file 91.11.02 by Tomohiro Ishikawa
227  * (ishikawa@gaia.cow.melco.CO.JP) 92.01.20 little modified (added #ifdef) by
228  * Masaru Oki 92.01.28 added mkdir() and rmdir() by Tomohiro Ishikawa
229  */
230
231 #if !defined(HAVE_FTRUNCATE) && !defined(_MINIX) && HAVE_LINK
232
233 /* ------------------------------------------------------------------------ */
234 int
235 rename(from, to)
236         const char *from, *to;
237 {
238         struct stat     s1, s2;
239         extern int      errno;
240
241         if (stat(from, &s1) < 0)
242                 return (-1);
243         /* is 'FROM' file a directory? */
244         if ((s1.st_mode & S_IFMT) == S_IFDIR) {
245                 errno = ENOTDIR;
246                 return (-1);
247         }
248         if (stat(to, &s2) >= 0) {       /* 'TO' exists! */
249                 /* is 'TO' file a directory? */
250                 if ((s2.st_mode & S_IFMT) == S_IFDIR) {
251                         errno = EISDIR;
252                         return (-1);
253                 }
254                 if (unlink(to) < 0)
255                         return (-1);
256         }
257         if (link(from, to) < 0)
258                 return (-1);
259         if (unlink(from) < 0)
260                 return (-1);
261         return (0);
262 }
263 #endif                          /* !HAVE_FTRUNCATE */
264 /* ------------------------------------------------------------------------ */
265
266 #ifndef HAVE_MKDIR
267 #ifndef MKDIRPATH
268 #define MKDIRPATH       "/bin/mkdir"
269 #endif
270 #ifndef RMDIRPATH
271 #define RMDIRPATH       "/bin/rmdir"
272 #endif
273 int
274 rmdir(path)
275         char           *path;
276 {
277         int             stat, rtn = 0;
278         char           *cmdname;
279         if ((cmdname = (char *) malloc(strlen(RMDIRPATH) + 1 + strlen(path) + 1))
280             == 0)
281                 return (-1);
282         strcpy(cmdname, RMDIRPATH);
283         *(cmdname + strlen(RMDIRPATH)) = ' ';
284         strcpy(cmdname + strlen(RMDIRPATH) + 1, path);
285         if ((stat = system(cmdname)) < 0)
286                 rtn = -1;       /* fork or exec error */
287         else if (stat) {        /* RMDIR command error */
288                 errno = EIO;
289                 rtn = -1;
290         }
291         free(cmdname);
292         return (rtn);
293 }
294
295 /* ------------------------------------------------------------------------ */
296 int
297 mkdir(path, mode)
298         char           *path;
299         int             mode;
300 {
301         int             child, stat;
302         char           *cmdname, *cmdpath = MKDIRPATH;
303         if ((cmdname = (char *) strrchr(cmdpath, '/')) == (char *) 0)
304                 cmdname = cmdpath;
305         if ((child = fork()) < 0)
306                 return (-1);    /* fork error */
307         else if (child) {       /* parent process */
308                 while (child != wait(&stat))    /* ignore signals */
309                         continue;
310         }
311         else {                  /* child process */
312                 int             maskvalue;
313                 maskvalue = umask(0);   /* get current umask() value */
314                 umask(maskvalue | (0777 & ~mode));      /* set it! */
315                 execl(cmdpath, cmdname, path, (char *) 0);
316                 /* never come here except execl is error */
317                 return (-1);
318         }
319         if (stat != 0) {
320                 errno = EIO;    /* cannot get error num. */
321                 return (-1);
322         }
323         return (0);
324 }
325 #endif
326
327 /*
328  * strucmp modified: Oct 29 1991 by Masaru Oki
329  */
330
331 #ifndef HAVE_STRCASECMP
332 static int
333 my_toupper(n)
334         register int    n;
335 {
336         if (n >= 'a' && n <= 'z')
337                 return n & (~('a' - 'A'));
338         return n;
339 }
340
341 /* ------------------------------------------------------------------------ */
342 int
343 strucmp(s, t)
344         register char  *s, *t;
345 {
346         while (my_toupper(*s++) == my_toupper(*t++))
347                 if (!*s || !*t)
348                         break;
349         if (!*s && !*t)
350                 return 0;
351         return 1;
352 }
353 #endif
354
355 /* ------------------------------------------------------------------------ */
356 #ifndef HAVE_MEMSET
357 /* Public Domain memset(3) */
358 char           *
359 memset(s, c, n)
360         char           *s;
361         int             c, n;
362 {
363         char           *p = s;
364         while (n--)
365                 *p++ = (char) c;
366         return s;
367 }
368 #endif
369
370 /* Local Variables: */
371 /* mode:c */
372 /* tab-width:4 */
373 /* compile-command:"gcc -c util.c" */
374 /* End: */