1 /* vms-misc.c -- BFD back-end for VMS/VAX (openVMS/VAX) and
2 EVAX (openVMS/Alpha) files.
3 Copyright (C) 1996-2016 Free Software Foundation, Inc.
4
5 Miscellaneous functions.
6
7 Written by Klaus K"ampf (kkaempf@rmi.de)
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
23
24 #if __STDC__
25 #include <stdarg.h>
26 #endif
27
28 #include "sysdep.h"
29 #include "bfd.h"
30 #include "bfdlink.h"
31 #include "libbfd.h"
32 #include "safe-ctype.h"
33
34 #ifdef VMS
35 #define __NEW_STARLET
36 #include <rms.h>
37 #include <unixlib.h>
38 #include <gen64def.h>
39 #include <starlet.h>
40 #define RME$C_SETRFM 0x00000001
41 #include <unistd.h>
42 #endif
43 #include <time.h>
44
45 #include "vms.h"
46 #include "vms/emh.h"
47
48 #if VMS_DEBUG
49 /* Debug functions. */
50
51 /* Debug function for all vms extensions evaluates environment
52 variable VMS_DEBUG for a numerical value on the first call all
53 error levels below this value are printed:
54
55 Levels:
56 1 toplevel bfd calls (functions from the bfd vector)
57 2 functions called by bfd calls
58 ...
59 9 almost everything
60
61 Level is also indentation level. Indentation is performed
62 if level > 0. */
63
64 void
_bfd_vms_debug(int level,char * format,...)65 _bfd_vms_debug (int level, char *format, ...)
66 {
67 static int min_level = -1;
68 static FILE *output = NULL;
69 char *eptr;
70 va_list args;
71 int abslvl = (level > 0) ? level : - level;
72
73 if (min_level == -1)
74 {
75 if ((eptr = getenv ("VMS_DEBUG")) != NULL)
76 {
77 min_level = atoi (eptr);
78 output = stderr;
79 }
80 else
81 min_level = 0;
82 }
83 if (output == NULL)
84 return;
85 if (abslvl > min_level)
86 return;
87
88 while (--level > 0)
89 fprintf (output, " ");
90 va_start (args, format);
91 vfprintf (output, format, args);
92 fflush (output);
93 va_end (args);
94 }
95
96 /* A debug function
97 hex dump 'size' bytes starting at 'ptr'. */
98
99 void
_bfd_hexdump(int level,unsigned char * ptr,int size,int offset)100 _bfd_hexdump (int level, unsigned char *ptr, int size, int offset)
101 {
102 unsigned char *lptr = ptr;
103 int count = 0;
104 long start = offset;
105
106 while (size-- > 0)
107 {
108 if ((count % 16) == 0)
109 vms_debug (level, "%08lx:", start);
110 vms_debug (-level, " %02x", *ptr++);
111 count++;
112 start++;
113 if (size == 0)
114 {
115 while ((count % 16) != 0)
116 {
117 vms_debug (-level, " ");
118 count++;
119 }
120 }
121 if ((count % 16) == 0)
122 {
123 vms_debug (-level, " ");
124 while (lptr < ptr)
125 {
126 vms_debug (-level, "%c", (*lptr < 32) ? '.' : *lptr);
127 lptr++;
128 }
129 vms_debug (-level, "\n");
130 }
131 }
132 if ((count % 16) != 0)
133 vms_debug (-level, "\n");
134 }
135 #endif
136
137
138 /* Copy sized string (string with fixed size) to new allocated area
139 size is string size (size of record) */
140
141 char *
_bfd_vms_save_sized_string(unsigned char * str,int size)142 _bfd_vms_save_sized_string (unsigned char *str, int size)
143 {
144 char *newstr = bfd_malloc ((bfd_size_type) size + 1);
145
146 if (newstr == NULL)
147 return NULL;
148 memcpy (newstr, (char *) str, (size_t) size);
149 newstr[size] = 0;
150
151 return newstr;
152 }
153
154 /* Copy counted string (string with size at first byte) to new allocated area
155 ptr points to size byte on entry */
156
157 char *
_bfd_vms_save_counted_string(unsigned char * ptr)158 _bfd_vms_save_counted_string (unsigned char *ptr)
159 {
160 int len = *ptr++;
161
162 return _bfd_vms_save_sized_string (ptr, len);
163 }
164
165 /* Object output routines. */
166
167 /* Begin new record.
168 Write 2 bytes rectype and 2 bytes record length. */
169
170 void
_bfd_vms_output_begin(struct vms_rec_wr * recwr,int rectype)171 _bfd_vms_output_begin (struct vms_rec_wr *recwr, int rectype)
172 {
173 vms_debug2 ((6, "_bfd_vms_output_begin (type %d)\n", rectype));
174
175 /* Record must have been closed. */
176 BFD_ASSERT (recwr->size == 0);
177
178 _bfd_vms_output_short (recwr, (unsigned int) rectype);
179
180 /* Placeholder for length. */
181 _bfd_vms_output_short (recwr, 0);
182 }
183
184 /* Begin new sub-record.
185 Write 2 bytes rectype, and 2 bytes record length. */
186
187 void
_bfd_vms_output_begin_subrec(struct vms_rec_wr * recwr,int rectype)188 _bfd_vms_output_begin_subrec (struct vms_rec_wr *recwr, int rectype)
189 {
190 vms_debug2 ((6, "_bfd_vms_output_begin_subrec (type %d)\n", rectype));
191
192 /* Subrecord must have been closed. */
193 BFD_ASSERT (recwr->subrec_offset == 0);
194
195 /* Save start of subrecord offset. */
196 recwr->subrec_offset = recwr->size;
197
198 /* Subrecord type. */
199 _bfd_vms_output_short (recwr, (unsigned int) rectype);
200
201 /* Placeholder for length. */
202 _bfd_vms_output_short (recwr, 0);
203 }
204
205 /* Set record/subrecord alignment. */
206
207 void
_bfd_vms_output_alignment(struct vms_rec_wr * recwr,int alignto)208 _bfd_vms_output_alignment (struct vms_rec_wr *recwr, int alignto)
209 {
210 vms_debug2 ((6, "_bfd_vms_output_alignment (%d)\n", alignto));
211 recwr->align = alignto;
212 }
213
214 /* Align the size of the current record (whose length is LENGTH).
215 Warning: this obviously changes the record (and the possible subrecord)
216 length. */
217
218 static void
_bfd_vms_output_align(struct vms_rec_wr * recwr,unsigned int length)219 _bfd_vms_output_align (struct vms_rec_wr *recwr, unsigned int length)
220 {
221 unsigned int real_size = recwr->size;
222 unsigned int aligncount;
223
224 /* Pad with 0 if alignment is required. */
225 aligncount = (recwr->align - (length % recwr->align)) % recwr->align;
226 vms_debug2 ((6, "align: adding %d bytes\n", aligncount));
227 while (aligncount-- > 0)
228 recwr->buf[real_size++] = 0;
229
230 recwr->size = real_size;
231 }
232
233 /* Ends current sub-record. Set length field. */
234
235 void
_bfd_vms_output_end_subrec(struct vms_rec_wr * recwr)236 _bfd_vms_output_end_subrec (struct vms_rec_wr *recwr)
237 {
238 int real_size = recwr->size;
239 int length;
240
241 /* Subrecord must be open. */
242 BFD_ASSERT (recwr->subrec_offset != 0);
243
244 length = real_size - recwr->subrec_offset;
245
246 if (length == 0)
247 return;
248
249 _bfd_vms_output_align (recwr, length);
250
251 /* Put length to buffer. */
252 bfd_putl16 ((bfd_vma) (recwr->size - recwr->subrec_offset),
253 recwr->buf + recwr->subrec_offset + 2);
254
255 /* Close the subrecord. */
256 recwr->subrec_offset = 0;
257 }
258
259 /* Ends current record (and write it). */
260
261 void
_bfd_vms_output_end(bfd * abfd,struct vms_rec_wr * recwr)262 _bfd_vms_output_end (bfd *abfd, struct vms_rec_wr *recwr)
263 {
264 vms_debug2 ((6, "_bfd_vms_output_end (size %u)\n", recwr->size));
265
266 /* Subrecord must have been closed. */
267 BFD_ASSERT (recwr->subrec_offset == 0);
268
269 if (recwr->size == 0)
270 return;
271
272 _bfd_vms_output_align (recwr, recwr->size);
273
274 /* Write the length word. */
275 bfd_putl16 ((bfd_vma) recwr->size, recwr->buf + 2);
276
277 /* File is open in undefined (UDF) format on VMS, but ultimately will be
278 converted to variable length (VAR) format. VAR format has a length
279 word first which must be explicitly output in UDF format. */
280 /* So, first the length word. */
281 bfd_bwrite (recwr->buf + 2, 2, abfd);
282
283 /* Align. */
284 if (recwr->size & 1)
285 recwr->buf[recwr->size++] = 0;
286
287 /* Then the record. */
288 bfd_bwrite (recwr->buf, (size_t) recwr->size, abfd);
289
290 recwr->size = 0;
291 }
292
293 /* Check remaining buffer size. Return what's left. */
294
295 int
_bfd_vms_output_check(struct vms_rec_wr * recwr,int size)296 _bfd_vms_output_check (struct vms_rec_wr *recwr, int size)
297 {
298 vms_debug2 ((6, "_bfd_vms_output_check (%d)\n", size));
299
300 return (MAX_OUTREC_SIZE - (recwr->size + size + MIN_OUTREC_LUFT));
301 }
302
303 /* Output byte (8 bit) value. */
304
305 void
_bfd_vms_output_byte(struct vms_rec_wr * recwr,unsigned int value)306 _bfd_vms_output_byte (struct vms_rec_wr *recwr, unsigned int value)
307 {
308 vms_debug2 ((6, "_bfd_vms_output_byte (%02x)\n", value));
309
310 *(recwr->buf + recwr->size) = value;
311 recwr->size += 1;
312 }
313
314 /* Output short (16 bit) value. */
315
316 void
_bfd_vms_output_short(struct vms_rec_wr * recwr,unsigned int value)317 _bfd_vms_output_short (struct vms_rec_wr *recwr, unsigned int value)
318 {
319 vms_debug2 ((6, "_bfd_vms_output_short (%04x)\n", value));
320
321 bfd_putl16 ((bfd_vma) value & 0xffff, recwr->buf + recwr->size);
322 recwr->size += 2;
323 }
324
325 /* Output long (32 bit) value. */
326
327 void
_bfd_vms_output_long(struct vms_rec_wr * recwr,unsigned long value)328 _bfd_vms_output_long (struct vms_rec_wr *recwr, unsigned long value)
329 {
330 vms_debug2 ((6, "_bfd_vms_output_long (%08lx)\n", value));
331
332 bfd_putl32 ((bfd_vma) value, recwr->buf + recwr->size);
333 recwr->size += 4;
334 }
335
336 /* Output quad (64 bit) value. */
337
338 void
_bfd_vms_output_quad(struct vms_rec_wr * recwr,bfd_vma value)339 _bfd_vms_output_quad (struct vms_rec_wr *recwr, bfd_vma value)
340 {
341 vms_debug2 ((6, "_bfd_vms_output_quad (%08lx)\n", (unsigned long)value));
342
343 bfd_putl64 (value, recwr->buf + recwr->size);
344 recwr->size += 8;
345 }
346
347 /* Output c-string as counted string. */
348
349 void
_bfd_vms_output_counted(struct vms_rec_wr * recwr,const char * value)350 _bfd_vms_output_counted (struct vms_rec_wr *recwr, const char *value)
351 {
352 int len;
353
354 vms_debug2 ((6, "_bfd_vms_output_counted (%s)\n", value));
355
356 len = strlen (value);
357 if (len == 0)
358 {
359 (*_bfd_error_handler) (_("_bfd_vms_output_counted called with zero bytes"));
360 return;
361 }
362 if (len > 255)
363 {
364 (*_bfd_error_handler) (_("_bfd_vms_output_counted called with too many bytes"));
365 return;
366 }
367 _bfd_vms_output_byte (recwr, (unsigned int) len & 0xff);
368 _bfd_vms_output_dump (recwr, (const unsigned char *)value, len);
369 }
370
371 /* Output character area. */
372
373 void
_bfd_vms_output_dump(struct vms_rec_wr * recwr,const unsigned char * data,int len)374 _bfd_vms_output_dump (struct vms_rec_wr *recwr, const unsigned char *data, int len)
375 {
376 vms_debug2 ((6, "_bfd_vms_output_dump (%d)\n", len));
377
378 if (len == 0)
379 return;
380
381 memcpy (recwr->buf + recwr->size, data, (size_t) len);
382 recwr->size += len;
383 }
384
385 /* Output count bytes of value. */
386
387 void
_bfd_vms_output_fill(struct vms_rec_wr * recwr,int value,int count)388 _bfd_vms_output_fill (struct vms_rec_wr *recwr, int value, int count)
389 {
390 vms_debug2 ((6, "_bfd_vms_output_fill (val %02x times %d)\n", value, count));
391
392 if (count == 0)
393 return;
394 memset (recwr->buf + recwr->size, value, (size_t) count);
395 recwr->size += count;
396 }
397
398 #ifdef VMS
399 /* Convert the file to variable record length format. This is done
400 using undocumented system call sys$modify().
401 Pure VMS version. */
402
403 static void
vms_convert_to_var(char * vms_filename)404 vms_convert_to_var (char * vms_filename)
405 {
406 struct FAB fab = cc$rms_fab;
407
408 fab.fab$l_fna = vms_filename;
409 fab.fab$b_fns = strlen (vms_filename);
410 fab.fab$b_fac = FAB$M_PUT;
411 fab.fab$l_fop = FAB$M_ESC;
412 fab.fab$l_ctx = RME$C_SETRFM;
413
414 sys$open (&fab);
415
416 fab.fab$b_rfm = FAB$C_VAR;
417
418 sys$modify (&fab);
419 sys$close (&fab);
420 }
421
422 static int
vms_convert_to_var_1(char * filename,int type)423 vms_convert_to_var_1 (char *filename, int type)
424 {
425 if (type != DECC$K_FILE)
426 return FALSE;
427 vms_convert_to_var (filename);
428 return TRUE;
429 }
430
431 /* Convert the file to variable record length format. This is done
432 using undocumented system call sys$modify().
433 Unix filename version. */
434
435 int
_bfd_vms_convert_to_var_unix_filename(const char * unix_filename)436 _bfd_vms_convert_to_var_unix_filename (const char *unix_filename)
437 {
438 if (decc$to_vms (unix_filename, &vms_convert_to_var_1, 0, 1) != 1)
439 return FALSE;
440 return TRUE;
441 }
442 #endif /* VMS */
443
444 /* Manufacture a VMS like time on a unix based system.
445 stolen from obj-vms.c. */
446
447 unsigned char *
get_vms_time_string(void)448 get_vms_time_string (void)
449 {
450 static unsigned char tbuf[18];
451 #ifndef VMS
452 char *pnt;
453 time_t timeb;
454
455 time (& timeb);
456 pnt = ctime (&timeb);
457 pnt[3] = 0;
458 pnt[7] = 0;
459 pnt[10] = 0;
460 pnt[16] = 0;
461 pnt[24] = 0;
462 sprintf ((char *) tbuf, "%2s-%3s-%s %s",
463 pnt + 8, pnt + 4, pnt + 20, pnt + 11);
464 #else
465 struct
466 {
467 int Size;
468 unsigned char *Ptr;
469 } Descriptor;
470 Descriptor.Size = 17;
471 Descriptor.Ptr = tbuf;
472 SYS$ASCTIM (0, &Descriptor, 0, 0);
473 #endif /* not VMS */
474
475 vms_debug2 ((6, "vmstimestring:'%s'\n", tbuf));
476
477 return tbuf;
478 }
479
480 /* Create module name from filename (ie, extract the basename and convert it
481 in upper cases). Works on both VMS and UNIX pathes.
482 The result has to be free(). */
483
484 char *
vms_get_module_name(const char * filename,bfd_boolean upcase)485 vms_get_module_name (const char *filename, bfd_boolean upcase)
486 {
487 char *fname, *fptr;
488 const char *fout;
489
490 /* Strip VMS path. */
491 fout = strrchr (filename, ']');
492 if (fout == NULL)
493 fout = strchr (filename, ':');
494 if (fout != NULL)
495 fout++;
496 else
497 fout = filename;
498
499 /* Strip UNIX path. */
500 fptr = strrchr (fout, '/');
501 if (fptr != NULL)
502 fout = fptr + 1;
503
504 fname = strdup (fout);
505
506 /* Strip suffix. */
507 fptr = strrchr (fname, '.');
508 if (fptr != 0)
509 *fptr = 0;
510
511 /* Convert to upper case and truncate at 31 characters.
512 (VMS object file format restricts module name length to 31). */
513 fptr = fname;
514 for (fptr = fname; *fptr != 0; fptr++)
515 {
516 if (*fptr == ';' || (fptr - fname) >= 31)
517 {
518 *fptr = 0;
519 break;
520 }
521 if (upcase)
522 *fptr = TOUPPER (*fptr);
523 }
524 return fname;
525 }
526
527 /* Compared to usual UNIX time_t, VMS time has less limits:
528 - 64 bit (63 bits in fact as the MSB must be 0)
529 - 100ns granularity
530 - epoch is Nov 17, 1858.
531 Here has the constants and the routines used to convert VMS from/to UNIX time.
532 The conversion routines don't assume 64 bits arithmetic.
533
534 Here we assume that the definition of time_t is the UNIX one, ie integer
535 type, expressing seconds since the epoch. */
536
537 /* UNIX time granularity for VMS, ie 1s / 100ns. */
538 #define VMS_TIME_FACTOR 10000000
539
540 /* Number of seconds since VMS epoch of the UNIX epoch. */
541 #define VMS_TIME_OFFSET 3506716800U
542
543 /* Convert a VMS time to a unix time. */
544
545 time_t
vms_time_to_time_t(unsigned int hi,unsigned int lo)546 vms_time_to_time_t (unsigned int hi, unsigned int lo)
547 {
548 unsigned int tmp;
549 unsigned int rlo;
550 int i;
551 time_t res;
552
553 /* First convert to seconds. */
554 tmp = hi % VMS_TIME_FACTOR;
555 hi = hi / VMS_TIME_FACTOR;
556 rlo = 0;
557 for (i = 0; i < 4; i++)
558 {
559 tmp = (tmp << 8) | (lo >> 24);
560 lo <<= 8;
561
562 rlo = (rlo << 8) | (tmp / VMS_TIME_FACTOR);
563 tmp %= VMS_TIME_FACTOR;
564 }
565 lo = rlo;
566
567 /* Return 0 in case of overflow. */
568 if (hi > 1
569 || (hi == 1 && lo >= VMS_TIME_OFFSET))
570 return 0;
571
572 /* Return 0 in case of underflow. */
573 if (hi == 0 && lo < VMS_TIME_OFFSET)
574 return 0;
575
576 res = lo - VMS_TIME_OFFSET;
577 if (res <= 0)
578 return 0;
579 return res;
580 }
581
582 /* Convert a time_t to a VMS time. */
583
584 void
vms_time_t_to_vms_time(time_t ut,unsigned int * hi,unsigned int * lo)585 vms_time_t_to_vms_time (time_t ut, unsigned int *hi, unsigned int *lo)
586 {
587 unsigned short val[4];
588 unsigned short tmp[4];
589 unsigned int carry;
590 int i;
591
592 /* Put into val. */
593 val[0] = ut & 0xffff;
594 val[1] = (ut >> 16) & 0xffff;
595 val[2] = sizeof (ut) > 4 ? (ut >> 32) & 0xffff : 0;
596 val[3] = sizeof (ut) > 4 ? (ut >> 48) & 0xffff : 0;
597
598 /* Add offset. */
599 tmp[0] = VMS_TIME_OFFSET & 0xffff;
600 tmp[1] = VMS_TIME_OFFSET >> 16;
601 tmp[2] = 0;
602 tmp[3] = 0;
603 carry = 0;
604 for (i = 0; i < 4; i++)
605 {
606 carry += tmp[i] + val[i];
607 val[i] = carry & 0xffff;
608 carry = carry >> 16;
609 }
610
611 /* Multiply by factor, well first by 10000 and then by 1000. */
612 carry = 0;
613 for (i = 0; i < 4; i++)
614 {
615 carry += val[i] * 10000;
616 val[i] = carry & 0xffff;
617 carry = carry >> 16;
618 }
619 carry = 0;
620 for (i = 0; i < 4; i++)
621 {
622 carry += val[i] * 1000;
623 val[i] = carry & 0xffff;
624 carry = carry >> 16;
625 }
626
627 /* Write the result. */
628 *lo = val[0] | (val[1] << 16);
629 *hi = val[2] | (val[3] << 16);
630 }
631
632 /* Convert a raw (stored in a buffer) VMS time to a unix time. */
633
634 time_t
vms_rawtime_to_time_t(unsigned char * buf)635 vms_rawtime_to_time_t (unsigned char *buf)
636 {
637 unsigned int hi = bfd_getl32 (buf + 4);
638 unsigned int lo = bfd_getl32 (buf + 0);
639
640 return vms_time_to_time_t (hi, lo);
641 }
642
643 void
vms_get_time(unsigned int * hi,unsigned int * lo)644 vms_get_time (unsigned int *hi, unsigned int *lo)
645 {
646 #ifdef VMS
647 struct _generic_64 t;
648
649 sys$gettim (&t);
650 *lo = t.gen64$q_quadword;
651 *hi = t.gen64$q_quadword >> 32;
652 #else
653 time_t t;
654
655 time (&t);
656 vms_time_t_to_vms_time (t, hi, lo);
657 #endif
658 }
659
660 /* Get the current time into a raw buffer BUF. */
661
662 void
vms_raw_get_time(unsigned char * buf)663 vms_raw_get_time (unsigned char *buf)
664 {
665 unsigned int hi, lo;
666
667 vms_get_time (&hi, &lo);
668 bfd_putl32 (lo, buf + 0);
669 bfd_putl32 (hi, buf + 4);
670 }
671