Debian Codegraph @

cmsmvs/cmsmvs.c

raw
1 /*
2 Copyright (c) 1990-1999 Info-ZIP. All rights reserved.
3
4 See the accompanying file LICENSE, version 1999-Oct-05 or later
5 (the contents of which are also included in zip.h) for terms of use.
6 If, for some reason, both of these files are missing, the Info-ZIP license
7 also may be found at: ftp://ftp.cdrom.com/pub/infozip/license.html
8 */
9 /*
10 * routines common to VM/CMS and MVS
11 */
12
13 #include "zip.h"
14
15 #include <stdio.h>
16 #include <time.h>
17 #include <errno.h>
18
19 #ifndef MVS /* MVS has perfectly good definitions of the following */
20 int stat(const char *path, struct stat *buf)
21 {
22 if ((buf->fp = fopen(path, "r")) != NULL) {
23 fldata_t fdata;
24 if (fldata( buf->fp, buf->fname, &fdata ) == 0) {
25 buf->st_dev = fdata.__device;
26 buf->st_mode = *(short *)(&fdata);
27 }
28 strcpy( buf->fname, path );
29 fclose(buf->fp);
30 }
31 return (buf->fp != NULL ? 0 : 1);
32 }
33 #endif /* MVS */
34
35
36 #ifndef UTIL /* the companion #endif is a bit of ways down ... */
37
38 #define PAD 0
39 #define PATH_END '/'
40
41 /* Library functions not in (most) header files */
42
43 #ifdef USE_ZIPMAIN
44 int main OF((void));
45 #endif
46
47 int utime OF((char *, ztimbuf *));
48
49 extern char *label;
50 local ulg label_time = 0;
51 local ulg label_mode = 0;
52 local time_t label_utim = 0;
53
54 #ifndef MVS /* MVS has perfectly good definitions of the following */
55 int fstat(int fd, struct stat *buf)
56 {
57 fldata_t fdata;
58
59 if ((fd != -1) && (fldata( (FILE *)fd, buf->fname, &fdata ) == 0)) {
60 buf->st_dev = fdata.__device;
61 buf->st_mode = *(short *)(&fdata);
62 buf->fp = (FILE *)fd;
63 return 0;
64 }
65 return -1;
66 }
67 #endif /* MVS */
68
69
70 char *ex2in(x, isdir, pdosflag)
71 char *x; /* external file name */
72 int isdir; /* input: x is a directory */
73 int *pdosflag; /* output: force MSDOS file attributes? */
74 /* Convert the external file name to a zip file name, returning the malloc'ed
75 string or NULL if not enough memory. */
76 {
77 char *n; /* internal file name (malloc'ed) */
78 char *t; /* shortened name */
79 int dosflag;
80 char mem[10] = ""; /* member name */
81 char ext[10] = ""; /* extension name */
82
83 dosflag = dosify; /* default for non-DOS non-OS/2 */
84
85 /* Find starting point in name before doing malloc */
86 for (t = x; *t == '/'; t++)
87 ;
88
89 /* Make changes, if any, to the copied name (leave original intact) */
90 if (!pathput)
91 t = last(t, PATH_END);
92
93 /* Malloc space for internal name and copy it */
94 if ((n = malloc(strlen(t) + 1)) == NULL)
95 return NULL;
96 strcpy(n, t);
97
98 #ifdef MVS
99 /* strip quotes from name, non-OE format */
100 if (*n == '\'' && (t = strrchr(n, '\'')) != n) {
101 if (!*(t+1)) {
102 /* yes, it is a quoted name */
103 int l = strlen(n) - 2;
104 memmove(n, n+1, l);
105 *(n+l) = '\0';
106 }
107 }
108 /* Change member names to fn.ext */
109 if (t = strrchr(n, '(')) {
110 *t = '\0';
111 strcpy(mem,t+1); /* Save member name */
112 if (t = strchr(mem, ')')) *t = '\0'; /* Set end of mbr */
113 /* Save extension */
114 if (t = strrchr(n, '.')) t++;
115 else t = n;
116 strcpy(ext,t);
117 /* Build name as "member.ext" */
118 strcpy(t,mem);
119 strcat(t,".");
120 strcat(t,ext);
121 }
122
123 /* Change all but the last '.' to '/' */
124 if (t = strrchr(n, '.')) {
125 while (--t > n)
126 if (*t == '.')
127 *t = '/';
128 }
129 #else
130 /* On CMS, remove the filemode (all past 2nd '.') */
131 if (t = strchr(n, '.'))
132 if (t = strchr(t+1, '.'))
133 *t = '\0';
134 t = n;
135 #endif
136
137 strcpy(n, t);
138
139 if (isdir == 42) return n; /* avoid warning on unused variable */
140
141 if (dosify)
142 msname(n); /* msname() needs string in native charset */
143
144 strtoasc(n, n);
145
146 /* Returned malloc'ed name */
147 if (pdosflag)
148 *pdosflag = dosflag;
149 return n;
150 }
151
152
153 char *in2ex(n)
154 char *n; /* internal file name */
155 /* Convert the zip file name to an external file name, returning the malloc'ed
156 string or NULL if not enough memory. */
157 {
158 char *x; /* external file name */
159
160 if ((x = malloc(strlen(n) + 1 + PAD)) == NULL)
161 return NULL;
162 strtoebc(x, n);
163 return x;
164 }
165
166
167 void stamp(f, d)
168 char *f; /* name of file to change */
169 ulg d; /* dos-style time to change it to */
170 /* Set last updated and accessed time of file f to the DOS time d. */
171 {
172 ztimbuf u; /* argument for utime() */
173
174 /* Convert DOS time to time_t format in u.actime and u.modtime */
175 u.actime = u.modtime = dos2unixtime(d);
176
177 utime(f, &u);
178 }
179
180
181 ulg filetime(f, a, n, t)
182 char *f; /* name of file to get info on */
183 ulg *a; /* return value: file attributes */
184 long *n; /* return value: file size */
185 iztimes *t; /* return value: access, modific. and creation times */
186 {
187 FILE *stream;
188 time_t ltime;
189
190 if (strcmp(f, "-") != 0) { /* if not compressing stdin */
191 Trace((mesg, "opening file '%s' with '%s'\n", f, FOPR));
192 if ((stream = fopen(f, FOPR)) == (FILE *)NULL) {
193 return 0;
194 } else {
195 if (n != NULL) {
196 /* With byteseek, this will work */
197 fseek(stream, 0L, SEEK_END);
198 *n = ftell(stream);
199 Trace((mesg, "file size = %lu\n", *((ulg *)n)));
200 }
201 fclose(stream);
202 }
203 }
204 else {
205 /* Reading from stdin */
206 if (n != NULL) {
207 *n = -1L;
208 }
209 }
210
211 /* Return current time for all the times -- for now */
212 time(&ltime);
213 if (t != NULL)
214 t->atime = t->mtime = t->ctime = ltime;
215
216 /* Set attributes (always a file) */
217 if (a != NULL)
218 *a = 0;
219
220 return unix2dostime(&ltime);
221 }
222
223
224
225 int set_extra_field(z, z_utim)
226 struct zlist far *z;
227 iztimes *z_utim;
228 /* create extra field and change z->att if desired */
229 {
230 fldata_t fdata;
231 FILE *stream;
232 char *eb_ptr;
233 #ifdef USE_EF_UT_TIME
234 extent ef_l_len = (EB_HEADSIZE+EB_UT_LEN(1));
235 #else /* !USE_EF_UT_TIME */
236 extent ef_l_len = 0;
237 #endif /* ?USE_EF_UT_TIME */
238 int set_cmsmvs_eb = 0;
239
240 /*translate_eol = 0;*/
241 if (aflag == ASCII) {
242 z->att = ASCII;
243 } else {
244 if (bflag)
245 z->att = BINARY;
246 else
247 z->att = __EBCDIC;
248 ef_l_len += sizeof(fdata)+EB_HEADSIZE;
249 set_cmsmvs_eb = 1;
250 }
251
252 if (ef_l_len > 0) {
253 z->extra = (char *)malloc(ef_l_len);
254 if (z->extra == NULL) {
255 printf("\nFLDATA : Unable to allocate memory !\n");
256 return ZE_MEM;
257 }
258 z->cext = z->ext = ef_l_len;
259 eb_ptr = z->cextra = z->extra;
260
261 if (set_cmsmvs_eb) {
262 if (bflag)
263 /*** stream = fopen(z->zname,"rb,type=record"); $RGH$ ***/
264 stream = fopen(z->name,"rb");
265 else
266 stream = fopen(z->name,"r");
267 if (stream == NULL) {
268 printf("\nFLDATA : Could not open file : %s !\n",z->name);
269 printf("Error %d: '%s'\n", errno, strerror(errno));
270 return ZE_NONE;
271 }
272
273 fldata(stream,z->name,&fdata);
274 /*put the system ID */
275 #ifdef VM_CMS
276 *(eb_ptr) = EF_VMCMS & 0xFF;
277 *(eb_ptr+1) = EF_VMCMS >> 8;
278 #else
279 *(eb_ptr) = EF_MVS & 0xFF;
280 *(eb_ptr+1) = EF_MVS >> 8;
281 #endif
282 *(eb_ptr+2) = sizeof(fdata) & 0xFF;
283 *(eb_ptr+3) = sizeof(fdata) >> 8;
284
285 memcpy(eb_ptr+EB_HEADSIZE,&fdata,sizeof(fdata));
286 fclose(stream);
287 #ifdef USE_EF_UT_TIME
288 eb_ptr += (sizeof(fdata)+EB_HEADSIZE);
289 #endif /* USE_EF_UT_TIME */
290 }
291 #ifdef USE_EF_UT_TIME
292 eb_ptr[0] = 0x55; /* ascii[(unsigned)('U')] */
293 eb_ptr[1] = 0x54; /* ascii[(unsigned)('T')] */
294 eb_ptr[2] = EB_UT_LEN(1); /* length of data part of e.f. */
295 eb_ptr[3] = 0;
296 eb_ptr[4] = EB_UT_FL_MTIME;
297 eb_ptr[5] = (char)(z_utim->mtime);
298 eb_ptr[6] = (char)(z_utim->mtime >> 8);
299 eb_ptr[7] = (char)(z_utim->mtime >> 16);
300 eb_ptr[8] = (char)(z_utim->mtime >> 24);
301 #endif /* USE_EF_UT_TIME */
302 }
303
304 return ZE_OK;
305 }
306
307 int deletedir(d)
308 char *d; /* directory to delete */
309 /* Delete the directory *d if it is empty, do nothing otherwise.
310 Return the result of rmdir(), delete(), or system().
311 For VMS, d must be in format [x.y]z.dir;1 (not [x.y.z]).
312 */
313 {
314 return 0;
315 }
316
317 #ifdef USE_ZIPMAIN
318 /* This function is called as main() to parse arguments */
319 /* into argc and argv. This is required for stand-alone */
320 /* execution. This calls the "real" main() when done. */
321
322 int main(void)
323 {
324 int argc=0;
325 char *argv[50];
326
327 int iArgLen;
328 char argstr[256];
329 char **pEPLIST, *pCmdStart, *pArgStart, *pArgEnd;
330
331 /* Get address of extended parameter list from S/370 Register 0 */
332 pEPLIST = (char **)__xregs(0);
333
334 /* Null-terminate the argument string */
335 pCmdStart = *(pEPLIST+0);
336 pArgStart = *(pEPLIST+1);
337 pArgEnd = *(pEPLIST+2);
338 iArgLen = pArgEnd - pCmdStart + 1;
339
340 /* Make a copy of the command string */
341 memcpy(argstr, pCmdStart, iArgLen);
342 argstr[iArgLen] = '\0'; /* Null-terminate */
343
344 /* Store first token (cmd) */
345 argv[argc++] = strtok(argstr, " ");
346
347 /* Store the rest (args) */
348 while (argv[argc-1])
349 argv[argc++] = strtok(NULL, " ");
350 argc--; /* Back off last NULL entry */
351
352 /* Call "real" main() function */
353 return zipmain(argc, argv);
354
355 }
356 #endif /* USE_ZIPMAIN */
357
358 #endif /* !UTIL */
359
360
361 /******************************/
362 /* Function version_local() */
363 /******************************/
364
365 void version_local()
366 {
367 char liblvlmsg [50+1];
368 char *compiler = "?";
369 char *platform = "?";
370 char complevel[64];
371
372 /* Map the runtime library level information */
373 union {
374 unsigned int iVRM;
375 struct {
376 unsigned int pd:4; /* Product designation */
377 unsigned int vv:4; /* Version */
378 unsigned int rr:8; /* Release */
379 unsigned int mm:16; /* Modification level */
380 } xVRM;
381 } VRM;
382
383
384 /* Break down the runtime library level */
385 VRM.iVRM = __librel();
386 sprintf(liblvlmsg, "Using runtime library level %s V%dR%dM%d",
387 (VRM.xVRM.pd==1 ? "LE" : "CE"),
388 VRM.xVRM.vv, VRM.xVRM.rr, VRM.xVRM.mm);
389 /* Note: LE = Language Environment, CE = Common Env. (C/370). */
390 /* This refers ONLY to the current runtimes, not the compiler. */
391
392
393 #ifdef VM_CMS
394 platform = "VM/CMS";
395 #ifdef __IBMC__
396 compiler = "IBM C";
397 #else
398 compiler = "C/370";
399 #endif
400 #endif
401
402 #ifdef MVS
403 platform = "MVS";
404 #ifdef __IBMC__
405 compiler = "IBM C/C++";
406 #else
407 compiler = "C/370";
408 #endif
409 #endif
410
411 #ifdef __COMPILER_VER__
412 VRM.iVRM = __COMPILER_VER__;
413 sprintf(complevel," V%dR%dM%d",
414 VRM.xVRM.vv, VRM.xVRM.rr, VRM.xVRM.mm);
415 #else
416 #ifdef __IBMC__
417 sprintf(complevel," V%dR%d", __IBMC__ / 100, (__IBMC__ % 100)/10);
418 #else
419 complevel[0] = '\0';
420 #endif
421 #endif
422
423
424 printf("Compiled with %s%s for %s%s%s.\n\n",
425
426 /* Add compiler name and level */
427 compiler, complevel,
428
429 /* Add platform */
430 platform,
431
432 /* Add timestamp */
433 #ifdef __DATE__
434 " on " __DATE__
435 #ifdef __TIME__
436 " at " __TIME__
437 #endif
438 #endif
439 ".\n",
440 liblvlmsg
441 );
442 } /* end function version_local() */