binutils/arsup.c

   1 /* arsup.c - Archive support for MRI compatibility
   2    Copyright (C) 1992-2021 Free Software Foundation, Inc.
   3
   4    This file is part of GNU Binutils.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21
  22 /* Contributed by Steve Chamberlain
  23    sac@cygnus.com
  24
  25    This file looks after requests from arparse.y, to provide the MRI
  26    style librarian command syntax + 1 word LIST.  */
  27
  28 #include "sysdep.h"
  29 #include "bfd.h"
  30 #include "libiberty.h"
  31 #include "filenames.h"
  32 #include "bucomm.h"
  33 #include "arsup.h"
  34
  35 static void map_over_list
  36   (bfd *, void (*function) (bfd *, bfd *), struct list *);
  37 static void ar_directory_doer (bfd *, bfd *);
  38 static void ar_addlib_doer (bfd *, bfd *);
  39
  40 extern int verbose;
  41 extern int deterministic;
  42
  43 static bfd *obfd;
  44 static char *real_name;
  45 static FILE *outfile;
  46
  47 static void
  48 map_over_list (bfd *arch, void (*function) (bfd *, bfd *), struct list *list)
  49 {
  50   bfd *head;
  51
  52   if (list == NULL)
  53     {
  54       bfd *next;
  55
  56       head = arch->archive_next;
  57       while (head != NULL)
  58         {
  59           next = head->archive_next;
  60           function (head, (bfd *) NULL);
  61           head = next;
  62         }
  63     }
  64   else
  65     {
  66       struct list *ptr;
  67
  68       /* This may appear to be a baroque way of accomplishing what we
  69          want.  however we have to iterate over the filenames in order
  70          to notice where a filename is requested but does not exist in
  71          the archive.  Ditto mapping over each file each time -- we
  72          want to hack multiple references.  */
  73       for (ptr = list; ptr; ptr = ptr->next)
  74         {
  75           bfd_boolean found = FALSE;
  76           bfd *prev = arch;
  77
  78           for (head = arch->archive_next; head; head = head->archive_next)
  79             {
  80               if (bfd_get_filename (head) != NULL
  81                   && FILENAME_CMP (ptr->name, bfd_get_filename (head)) == 0)
  82                 {
  83                   found = TRUE;
  84                   function (head, prev);
  85                 }
  86               prev = head;
  87             }
  88           if (! found)
  89             fprintf (stderr, _("No entry %s in archive.\n"), ptr->name);
  90         }
  91     }
  92 }
  93
  94
  95
  96 static void
  97 ar_directory_doer (bfd *abfd, bfd *ignore ATTRIBUTE_UNUSED)
  98 {
  99   print_arelt_descr(outfile, abfd, verbose, FALSE);
 100 }
 101
 102 void
 103 ar_directory (char *ar_name, struct list *list, char *output)
 104 {
 105   bfd *arch;
 106
 107   arch = open_inarch (ar_name, (char *) NULL);
 108   if (output)
 109     {
 110       outfile = fopen(output,"w");
 111       if (outfile == 0)
 112         {
 113           outfile = stdout;
 114           fprintf (stderr,_("Can't open file %s\n"), output);
 115           output = 0;
 116         }
 117     }
 118   else
 119     outfile = stdout;
 120
 121   map_over_list (arch, ar_directory_doer, list);
 122
 123   bfd_close (arch);
 124
 125   if (output)
 126    fclose (outfile);
 127 }
 128
 129 void
 130 prompt (void)
 131 {
 132   extern int interactive;
 133
 134   if (interactive)
 135     {
 136       printf ("AR >");
 137       fflush (stdout);
 138     }
 139 }
 140
 141 void
 142 maybequit (void)
 143 {
 144   if (! interactive)
 145     xexit (9);
 146 }
 147
 148
 149 void
 150 ar_open (char *name, int t)
 151 {
 152   char *tname;
 153   const char *bname = lbasename (name);
 154   real_name = name;
 155
 156   /* Prepend tmp- to the beginning, to avoid file-name clashes after
 157      truncation on filesystems with limited namespaces (DOS).  */
 158   if (asprintf (&tname, "%.*stmp-%s", (int) (bname - name), name, bname) == -1)
 159     {
 160       fprintf (stderr, _("%s: Can't allocate memory for temp name (%s)\n"),
 161                program_name, strerror(errno));
 162       maybequit ();
 163       return;
 164     }
 165
 166   obfd = bfd_openw (tname, NULL);
 167
 168   if (!obfd)
 169     {
 170       fprintf (stderr,
 171                _("%s: Can't open output archive %s\n"),
 172                program_name,  tname);
 173
 174       maybequit ();
 175     }
 176   else
 177     {
 178       if (!t)
 179         {
 180           bfd **ptr;
 181           bfd *element;
 182           bfd *ibfd;
 183
 184           ibfd = bfd_openr (name, NULL);
 185
 186           if (!ibfd)
 187             {
 188               fprintf (stderr,_("%s: Can't open input archive %s\n"),
 189                        program_name, name);
 190               maybequit ();
 191               return;
 192             }
 193
 194           if (!bfd_check_format(ibfd, bfd_archive))
 195             {
 196               fprintf (stderr,
 197                        _("%s: file %s is not an archive\n"),
 198                        program_name, name);
 199               maybequit ();
 200               return;
 201             }
 202
 203           ptr = &(obfd->archive_head);
 204           element = bfd_openr_next_archived_file (ibfd, NULL);
 205
 206           while (element)
 207             {
 208               *ptr = element;
 209               ptr = &element->archive_next;
 210               element = bfd_openr_next_archived_file (ibfd, element);
 211             }
 212         }
 213
 214       bfd_set_format (obfd, bfd_archive);
 215
 216       obfd->has_armap = 1;
 217       obfd->is_thin_archive = 0;
 218     }
 219 }
 220
 221 static void
 222 ar_addlib_doer (bfd *abfd, bfd *prev)
 223 {
 224   /* Add this module to the output bfd.  */
 225   if (prev != NULL)
 226     prev->archive_next = abfd->archive_next;
 227
 228   abfd->archive_next = obfd->archive_head;
 229   obfd->archive_head = abfd;
 230 }
 231
 232 void
 233 ar_addlib (char *name, struct list *list)
 234 {
 235   if (obfd == NULL)
 236     {
 237       fprintf (stderr, _("%s: no output archive specified yet\n"), program_name);
 238       maybequit ();
 239     }
 240   else
 241     {
 242       bfd *arch;
 243
 244       arch = open_inarch (name, (char *) NULL);
 245       if (arch != NULL)
 246         map_over_list (arch, ar_addlib_doer, list);
 247
 248       /* Don't close the bfd, since it will make the elements disappear.  */
 249     }
 250 }
 251
 252 void
 253 ar_addmod (struct list *list)
 254 {
 255   if (!obfd)
 256     {
 257       fprintf (stderr, _("%s: no open output archive\n"), program_name);
 258       maybequit ();
 259     }
 260   else
 261     {
 262       while (list)
 263         {
 264           bfd *abfd;
 265
 266 #if BFD_SUPPORTS_PLUGINS
 267           abfd = bfd_openr (list->name, "plugin");
 268 #else
 269           abfd = bfd_openr (list->name, NULL);
 270 #endif
 271           if (!abfd)
 272             {
 273               fprintf (stderr, _("%s: can't open file %s\n"),
 274                        program_name, list->name);
 275               maybequit ();
 276             }
 277           else
 278             {
 279               abfd->archive_next = obfd->archive_head;
 280               obfd->archive_head = abfd;
 281             }
 282           list = list->next;
 283         }
 284     }
 285 }
 286
 287
 288 void
 289 ar_clear (void)
 290 {
 291   if (obfd)
 292     obfd->archive_head = 0;
 293 }
 294
 295 void
 296 ar_delete (struct list *list)
 297 {
 298   if (!obfd)
 299     {
 300       fprintf (stderr, _("%s: no open output archive\n"), program_name);
 301       maybequit ();
 302     }
 303   else
 304     {
 305       while (list)
 306         {
 307           /* Find this name in the archive.  */
 308           bfd *member = obfd->archive_head;
 309           bfd **prev = &(obfd->archive_head);
 310           int found = 0;
 311
 312           while (member)
 313             {
 314               if (FILENAME_CMP (bfd_get_filename (member), list->name) == 0)
 315                 {
 316                   *prev = member->archive_next;
 317                   found = 1;
 318                 }
 319               else
 320                 prev = &(member->archive_next);
 321
 322               member = member->archive_next;
 323             }
 324
 325           if (!found)
 326             {
 327               fprintf (stderr, _("%s: can't find module file %s\n"),
 328                        program_name, list->name);
 329               maybequit ();
 330             }
 331
 332           list = list->next;
 333         }
 334     }
 335 }
 336
 337 void
 338 ar_save (void)
 339 {
 340   if (!obfd)
 341     {
 342       fprintf (stderr, _("%s: no open output archive\n"), program_name);
 343       maybequit ();
 344     }
 345   else
 346     {
 347       char *ofilename = xstrdup (bfd_get_filename (obfd));
 348       bfd_boolean skip_stat = FALSE;
 349       struct stat target_stat;
 350       int ofd = -1;
 351
 352       if (deterministic > 0)
 353         obfd->flags |= BFD_DETERMINISTIC_OUTPUT;
 354
 355 #if !defined (_WIN32) || defined (__CYGWIN32__)
 356       /* It's OK to fail; at worst it will result in SMART_RENAME using a slow
 357          copy fallback to write the output.  */
 358       ofd = dup (fileno ((FILE *) obfd->iostream));
 359       if (lstat (real_name, &target_stat) != 0)
 360         skip_stat = TRUE;
 361 #endif
 362
 363       bfd_close (obfd);
 364
 365       smart_rename (ofilename, real_name, ofd,
 366                     skip_stat ? NULL : &target_stat, 0);
 367       obfd = 0;
 368       free (ofilename);
 369     }
 370 }
 371
 372 void
 373 ar_replace (struct list *list)
 374 {
 375   if (!obfd)
 376     {
 377       fprintf (stderr, _("%s: no open output archive\n"), program_name);
 378       maybequit ();
 379     }
 380   else
 381     {
 382       while (list)
 383         {
 384           /* Find this name in the archive.  */
 385           bfd *member = obfd->archive_head;
 386           bfd **prev = &(obfd->archive_head);
 387           int found = 0;
 388
 389           while (member)
 390             {
 391               if (FILENAME_CMP (bfd_get_filename (member), list->name) == 0)
 392                 {
 393                   /* Found the one to replace.  */
 394                   bfd *abfd = bfd_openr (list->name, NULL);
 395
 396                   if (!abfd)
 397                     {
 398                       fprintf (stderr, _("%s: can't open file %s\n"),
 399                                program_name, list->name);
 400                       maybequit ();
 401                     }
 402                   else
 403                     {
 404                       *prev = abfd;
 405                       abfd->archive_next = member->archive_next;
 406                       found = 1;
 407                     }
 408                 }
 409               else
 410                 {
 411                   prev = &(member->archive_next);
 412                 }
 413               member = member->archive_next;
 414             }
 415
 416           if (!found)
 417             {
 418               bfd *abfd = bfd_openr (list->name, NULL);
 419
 420               fprintf (stderr,_("%s: can't find module file %s\n"),
 421                        program_name, list->name);
 422               if (!abfd)
 423                 {
 424                   fprintf (stderr, _("%s: can't open file %s\n"),
 425                            program_name, list->name);
 426                   maybequit ();
 427                 }
 428               else
 429                 *prev = abfd;
 430             }
 431
 432           list = list->next;
 433         }
 434     }
 435 }
 436
 437 /* And I added this one.  */
 438 void
 439 ar_list (void)
 440 {
 441   if (!obfd)
 442     {
 443       fprintf (stderr, _("%s: no open output archive\n"), program_name);
 444       maybequit ();
 445     }
 446   else
 447     {
 448       bfd *abfd;
 449
 450       outfile = stdout;
 451       verbose =1 ;
 452       printf (_("Current open archive is %s\n"), bfd_get_filename (obfd));
 453
 454       for (abfd = obfd->archive_head;
 455            abfd != (bfd *)NULL;
 456            abfd = abfd->archive_next)
 457         ar_directory_doer (abfd, (bfd *) NULL);
 458     }
 459 }
 460
 461 void
 462 ar_end (void)
 463 {
 464   if (obfd)
 465     {
 466       bfd_cache_close (obfd);
 467       unlink (bfd_get_filename (obfd));
 468     }
 469 }
 470
 471 void
 472 ar_extract (struct list *list)
 473 {
 474   if (!obfd)
 475     {
 476       fprintf (stderr, _("%s: no open archive\n"), program_name);
 477       maybequit ();
 478     }
 479   else
 480     {
 481       while (list)
 482         {
 483           /* Find this name in the archive.  */
 484           bfd *member = obfd->archive_head;
 485           int found = 0;
 486
 487           while (member && !found)
 488             {
 489               if (FILENAME_CMP (bfd_get_filename (member), list->name) == 0)
 490                 {
 491                   extract_file (member);
 492                   found = 1;
 493                 }
 494
 495               member = member->archive_next;
 496             }
 497
 498           if (!found)
 499             {
 500               bfd_openr (list->name, NULL);
 501               fprintf (stderr, _("%s: can't find module file %s\n"),
 502                        program_name, list->name);
 503             }
 504
 505           list = list->next;
 506         }
 507     }
 508 }