Source_File * source_file_lookup_path (const char *path) { Source_File *sf; for (sf = first_src_file; sf; sf = sf->next) { if (FILENAME_CMP (path, sf->name) == 0) break; } if (!sf) { /* Create a new source file descriptor. */ sf = (Source_File *) xmalloc (sizeof (*sf)); memset (sf, 0, sizeof (*sf)); sf->name = xstrdup (path); sf->next = first_src_file; first_src_file = sf; } return sf; }
Source_File * source_file_lookup_name (const char *filename) { const char *fname; Source_File *sf; /* The user cannot know exactly how a filename will be stored in the debugging info (e.g., ../include/foo.h vs. /usr/include/foo.h). So we simply compare the filename component of a path only. */ for (sf = first_src_file; sf; sf = sf->next) { fname = strrchr (sf->name, '/'); if (fname) ++fname; else fname = sf->name; if (FILENAME_CMP (filename, fname) == 0) break; } return sf; }
static bfd_boolean is_sysrooted_pathname (const char *name, bfd_boolean notsame) { char * realname = ld_canon_sysroot ? lrealpath (name) : NULL; int len; bfd_boolean result; if (! realname) return FALSE; len = strlen (realname); if (((! notsame && len == ld_canon_sysroot_len) || (len >= ld_canon_sysroot_len && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len]) && (realname[ld_canon_sysroot_len] = '\0') == '\0')) && FILENAME_CMP (ld_canon_sysroot, realname) == 0) result = TRUE; else result = FALSE; if (realname) free (realname); return result; }
static void add_entry (struct entry **entp, const char *filename, int is_system) { int len; struct entry *n; n = XNEW (struct entry); n->flags = is_system ? FLAG_SYSTEM : 0; n->next = NULL; len = strlen (filename); if (len > 4 && (FILENAME_CMP (filename + len - 4, ".zip") == 0 || FILENAME_CMP (filename + len - 4, ".jar") == 0)) { n->flags |= FLAG_ZIP; /* If the user uses -classpath then he'll have to include libgcj.jar in the value. We check for this in a simplistic way. Symlinks will fool this test. This is only used for -MM and -MMD, so it probably isn't terribly important. */ if (! FILENAME_CMP (filename, LIBGCJ_ZIP_FILE)) n->flags |= FLAG_SYSTEM; } /* Note that we add a trailing separator to `.zip' names as well. This is a little hack that lets the searching code in jcf-io.c work more easily. Eww. */ if (! IS_DIR_SEPARATOR (filename[len - 1])) { char *f2 = (char *) alloca (len + 2); strcpy (f2, filename); f2[len] = DIR_SEPARATOR; f2[len + 1] = '\0'; n->name = xstrdup (f2); ++len; } else n->name = xstrdup (filename); if (len > longest_path) longest_path = len; append_entry (entp, n); }
/* Find the result for having already called info_find_fullpath () with FILENAME. */ static char * lookup_info_filename (char *filename) { if (filename && names_and_files) { register int i; for (i = 0; names_and_files[i]; i++) { if (FILENAME_CMP (names_and_files[i]->filename, filename) == 0) return names_and_files[i]->expansion; } } return NULL; }
static void map_over_list (bfd *arch, void (*function) (bfd *, bfd *), struct list *list) { bfd *head; if (list == NULL) { bfd *next; head = arch->archive_next; while (head != NULL) { next = head->archive_next; function (head, (bfd *) NULL); head = next; } } else { struct list *ptr; /* This may appear to be a baroque way of accomplishing what we want. however we have to iterate over the filenames in order to notice where a filename is requested but does not exist in the archive. Ditto mapping over each file each time -- we want to hack multiple references. */ for (ptr = list; ptr; ptr = ptr->next) { bfd_boolean found = FALSE; bfd *prev = arch; for (head = arch->archive_next; head; head = head->archive_next) { if (head->filename != NULL && FILENAME_CMP (ptr->name, head->filename) == 0) { found = TRUE; function (head, prev); } prev = head; } if (! found) fprintf (stderr, _("No entry %s in archive.\n"), ptr->name); } } }
/* * Look for the file in our directory structure. Return 1 if successful, * 0 if not found. Fill in the size and starting position. */ static boolean find_file(const char *name, library ** lib, long *startp, long *sizep) { int i, j; library *lp; for (i = 0; i < MAX_LIBS && dlb_libs[i].fdata; i++) { lp = &dlb_libs[i]; for (j = 0; j < lp->nentries; j++) { if (FILENAME_CMP(name, lp->dir[j].fname) == 0) { *lib = lp; *startp = lp->dir[j].foffset; *sizep = lp->dir[j].fsize; return TRUE; } } } *lib = NULL; *startp = *sizep = 0; return FALSE; }
static bfd_boolean is_sysrooted_pathname (const char *name) { char *realname; int len; bfd_boolean result; if (ld_canon_sysroot == NULL) return FALSE; realname = lrealpath (name); len = strlen (realname); result = FALSE; if (len > ld_canon_sysroot_len && IS_DIR_SEPARATOR (realname[ld_canon_sysroot_len])) { realname[ld_canon_sysroot_len] = '\0'; result = FILENAME_CMP (ld_canon_sysroot, realname) == 0; } free (realname); return result; }
int main(int argc, char *argv[]) { int i, r; int ap=2; /* argument pointer */ int cp; /* command pointer */ int iseen=0, fseen=0, verbose=0; /* flags */ char action=' '; library lib; if (argc > 0 && argv[0] && *argv[0]) progname = argv[0]; if (argc<2) { usage(); /* doesn't return */ } for (cp=0; argv[1][cp]; cp++){ switch(argv[1][cp]){ default: usage(); /* doesn't return */ case '-': /* silently ignore */ break; case '?': case 'h': verbose_help(); break; case 'I': if (ap == argc) usage(); list_file=argv[ap++]; if (iseen) printf("Warning: multiple I options. Previous ignored.\n"); iseen=1; break; case 'f': if (ap == argc) usage(); library_file=argv[ap++]; if (fseen) printf("Warning: multiple f options. Previous ignored.\n"); fseen=1; break; case 'C': if (ap == argc) usage(); if (chdir(argv[ap++])){ printf("Can't chdir to %s\n",argv[--ap]); xexit(EXIT_FAILURE); } break; case 'v': verbose=1; break; case 't': case 'c': case 'x': if (action != ' '){ printf("Only one of t,x,c may be specified.\n"); usage(); } action=argv[1][cp]; break; } } if (argv[ap] && iseen){ printf("Too many arguments.\n"); xexit(EXIT_FAILURE); } switch(action){ default: printf("Internal error - action.\n"); xexit(EXIT_FAILURE); break; case 't': /* list archive */ if (!open_library(library_file, &lib)) { printf("Can't open dlb file\n"); xexit(EXIT_FAILURE); } for (i = 0; i < lib.nentries; i++) { if (verbose) printf("%-14s %6ld %6ld\n", lib.dir[i].fname, lib.dir[i].foffset, lib.dir[i].fsize); else printf("%s\n", lib.dir[i].fname); } if (verbose) printf("Revision:%ld File count:%ld String size:%ld\n", lib.rev, lib.nentries, lib.strsize); close_library(&lib); xexit(EXIT_SUCCESS); case 'x': { /* extract archive contents */ int f, n; long remainder, total_read; char buf[BUFSIZ]; if (!open_library(library_file, &lib)) { printf("Can't open dlb file\n"); xexit(EXIT_FAILURE); } for (i = 0; i < lib.nentries; i++) { if (argv[ap]) { /* if files are listed, see if current is wanted */ int c; for (c = ap; c < argc; c++) if (!FILENAME_CMP(lib.dir[i].fname, argv[c])) break; if (c == argc) continue; /* skip */ } else if (!FILENAME_CMP(lib.dir[i].fname, DLB_DIRECTORY)) { /* * Don't extract the directory unless the user * specifically asks for it. * * Perhaps we should never extract the directory??? */ continue; } fseek(lib.fdata, lib.dir[i].foffset, SEEK_SET); f = open(lib.dir[i].fname, O_WRONLY|O_TRUNC|O_BINARY|O_CREAT, 0640); if (f < 0) { printf("Can't create '%s'\n", lib.dir[i].fname); xexit(EXIT_FAILURE); } /* read chunks from library and write them out */ total_read = 0; do { remainder = lib.dir[i].fsize - total_read; if (remainder > (long) sizeof(buf)) r = (int) sizeof(buf); else r = remainder; n = fread(buf, 1, r, lib.fdata); if (n != r) { printf("Read Error in '%s'\n", lib.dir[i].fname); xexit(EXIT_FAILURE); } if (write(f, buf, n) != n) { printf("Write Error in '%s'\n", lib.dir[i].fname); xexit(EXIT_FAILURE); } total_read += n; } while (total_read != lib.dir[i].fsize); close(f); if (verbose) printf("x %s\n", lib.dir[i].fname); } close_library(&lib); xexit(EXIT_SUCCESS); } case 'c': /* create archive */ { libdir ld[MAX_DLB_FILES]; char buf[BUFSIZ]; int fd, out, nfiles = 0; long dir_size, slen, flen, fsiz; boolean rewrite_directory = FALSE; /* * Get names from either/both an argv list and a file * list. This does not do any duplicate checking */ /* get file name in argv list */ if (argv[ap]) { for ( ; ap < argc; ap++, nfiles++) { if (nfiles >= MAX_DLB_FILES) { printf("Too many dlb files! Stopping at %d.\n", MAX_DLB_FILES); xexit(EXIT_FAILURE); } ld[nfiles].fname = malloc(strlen(argv[ap]) + 1); strcpy(ld[nfiles].fname, argv[ap]); } } if (iseen) { /* want to do a list file */ FILE *list = fopen(list_file, "r"); if (!list) { printf("Can't open %s\n",list_file); xexit(EXIT_FAILURE); } /* get file names, one per line */ for ( ; fgets(buf, sizeof(buf), list); nfiles++) { if (nfiles >= MAX_DLB_FILES) { printf("Too many dlb files! Stopping at %d.\n", MAX_DLB_FILES); xexit(EXIT_FAILURE); } *(eos(buf)-1) = '\0'; /* strip newline */ ld[nfiles].fname = malloc(strlen(buf) + 1); strcpy(ld[nfiles].fname, buf); } fclose(list); } if (nfiles == 0) { printf("No files to archive\n"); xexit(EXIT_FAILURE); } /* * Get file sizes and name string length. Don't include * the directory information yet. */ for (i = 0, slen = 0, flen = 0; i < nfiles; i++) { fd = open(ld[i].fname, O_RDONLY|O_BINARY, 0); if (fd < 0) { printf("Can't open %s\n", ld[i].fname); xexit(EXIT_FAILURE); } ld[i].fsize = lseek(fd, 0, SEEK_END); ld[i].foffset = flen; slen += strlen(ld[i].fname); /* don't add null (yet) */ flen += ld[i].fsize; close(fd); } /* open output file */ out = open(library_file, O_RDWR|O_TRUNC|O_BINARY|O_CREAT, FCMASK); if (out < 0) { printf("Can't open %s for output\n", library_file); xexit(EXIT_FAILURE); } /* caculate directory size */ dir_size = 40 /* header line (see below) */ + ((nfiles+1)*11) /* handling+file offset+SP+newline */ + slen+strlen(DLB_DIRECTORY); /* file names */ /* write directory */ write_dlb_directory(out, nfiles, ld, slen, dir_size, flen); flen = 0L; /* write each file */ for (i = 0; i < nfiles; i++) { fd = open(ld[i].fname, O_RDONLY|O_BINARY, 0); if (fd < 0) { printf("Can't open input file '%s'\n", ld[i].fname); xexit(EXIT_FAILURE); } if (verbose) printf("%s\n",ld[i].fname); fsiz = 0L; while ((r = read(fd, buf, sizeof buf)) != 0) { if (r == -1) { printf("Read Error in '%s'\n", ld[i].fname); xexit(EXIT_FAILURE); } if (write(out, buf, r) != r) { printf("Write Error in '%s'\n", ld[i].fname); xexit(EXIT_FAILURE); } fsiz += r; } close(fd); if (fsiz != ld[i].fsize) rewrite_directory = TRUE; /* in case directory rewrite is needed */ ld[i].fsize = fsiz; ld[i].foffset = flen; flen += fsiz; } if (rewrite_directory) { if (verbose) printf("(rewriting dlb directory info)\n"); lseek(out, 0, SEEK_SET); /* rewind */ write_dlb_directory(out, nfiles, ld, slen, dir_size, flen); } for (i = 0; i < nfiles; i++) free(ld[i].fname), ld[i].fname = 0; close(out); xexit(EXIT_SUCCESS); } } xexit(EXIT_SUCCESS); /*NOTREACHED*/ return 0; }