1 /* opncls.c -- open and close a bfd. */
3 /* Copyright (C) 1990, 1991 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Diddler.
7 BFD is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 1, or (at your option)
12 BFD is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with BFD; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
27 extern void bfd_cache_init();
28 FILE *bfd_open_file();
30 /* fdopen is a loser -- we should use stdio exclusively. Unfortunately
31 if we do that we can't use fcntl. */
35 Locking is loosely controlled by the preprocessor variable
36 BFD_LOCKS. I say loosely because Unix barely understands locking
37 -- at least in BSD it doesn't affect programs which don't
38 explicitly use it! That is to say it's practically useless, though
39 if everyone uses this library you'll be OK.
41 From among the many and varied lock facilities available, (none of
42 which, of course, knows about any other) we use the fcntl locks,
43 because they're Posix.
45 The reason that bfd_openr and bfd_fdopenr exist, yet only bfd_openw
46 exists is because of locking. When we do output, we lock the
47 filename file for output, then open a temporary file which does not
48 actually get its correct filename until closing time. This is
49 safest, but requires the asymmetry in read and write entry points.
51 Perhaps, since unix has so many different kinds of locking anyway,
52 we should use the emacs lock scheme?... */
54 #define obstack_chunk_alloc malloc
55 #define obstack_chunk_free free
57 /* Return a new BFD. All BFD's are allocated through this routine. */
63 obstack_begin(&tmp,128);
65 nbfd = (bfd *)obstack_alloc(&tmp,sizeof(bfd));
66 memset((PTR)nbfd, 0, sizeof (bfd)); /* Clear it */
70 nbfd->direction = no_direction;
71 nbfd->iostream = NULL;
73 nbfd->sections = (asection *)NULL;
74 nbfd->format = bfd_unknown;
75 nbfd->my_archive = (bfd *)NULL;
77 nbfd->opened_once = false;
78 nbfd->output_has_begun = false;
79 nbfd->section_count = 0;
80 nbfd->usrdata = (PTR)NULL;
81 nbfd->sections = (asection *)NULL;
82 nbfd->cacheable = false;
83 nbfd->flags = NO_FLAGS;
88 /* Allocate a new BFD as a member of archive OBFD. */
90 bfd *new_bfd_contained_in(obfd)
93 bfd *nbfd = new_bfd();
94 nbfd->xvec = obfd->xvec;
95 nbfd->my_archive = obfd;
96 nbfd->direction = read_direction;
100 /** bfd_openr, bfd_fdopenr -- open for reading.
101 Returns a pointer to a freshly-allocated bfd on success, or NULL. */
104 DEFUN(bfd_openr, (filename, target),
105 CONST char *filename AND
109 bfd_target *target_vec;
111 target_vec = bfd_find_target (target);
112 if (target_vec == NULL) {
113 bfd_error = invalid_target;
117 bfd_error = system_call_error;
120 bfd_error = no_memory;
124 nbfd->filename = filename;
125 nbfd->xvec = target_vec;
126 nbfd->direction = read_direction;
128 if (bfd_open_file (nbfd) == NULL) {
129 bfd_error = system_call_error; /* File didn't exist, or some such */
137 /* Don't try to `optimize' this function:
139 o - We lock using stack space so that interrupting the locking
140 won't cause a storage leak.
141 o - We open the file stream last, since we don't want to have to
142 close it if anything goes wrong. Closing the stream means closing
143 the file descriptor too, even though we didn't open it.
147 DEFUN(bfd_fdopenr,(filename, target, fd),
148 CONST char *filename AND
149 CONST char *target AND
153 bfd_target *target_vec;
156 struct flock lock, *lockp = &lock;
159 target_vec = bfd_find_target (target);
160 if (target_vec == NULL) {
161 bfd_error = invalid_target;
165 bfd_error = system_call_error;
167 fdflags = fcntl (fd, F_GETFL);
168 if (fdflags == -1) return NULL;
171 lockp->l_type = F_RDLCK;
172 if (fcntl (fd, F_SETLKW, lockp) == -1) return NULL;
178 bfd_error = no_memory;
182 nbfd->lock = (struct flock *) (nbfd + 1);
184 /* if the fd were open for read only, this still would not hurt: */
185 nbfd->iostream = (char *) fdopen (fd, "r+");
186 if (nbfd->iostream == NULL) {
187 (void) obstack_free (&nbfd->memory, (PTR)0);
191 /* OK, put everything where it belongs */
193 nbfd->filename = filename;
194 nbfd->xvec = target_vec;
196 /* As a special case we allow a FD open for read/write to
197 be written through, although doing so requires that we end
198 the previous clause with a preposition. */
199 switch (fdflags & O_ACCMODE) {
200 case O_RDONLY: nbfd->direction = read_direction; break;
201 case O_WRONLY: nbfd->direction = write_direction; break;
202 case O_RDWR: nbfd->direction = both_direction; break;
207 memcpy (nbfd->lock, lockp, sizeof (struct flock))
210 bfd_cache_init (nbfd);
215 /** bfd_openw -- open for writing.
216 Returns a pointer to a freshly-allocated bfd on success, or NULL.
218 See comment by bfd_fdopenr before you try to modify this function. */
221 DEFUN(bfd_openw,(filename, target),
222 CONST char *filename AND
226 bfd_target *target_vec;
228 target_vec = bfd_find_target (target);
229 if (target_vec == NULL) return NULL;
231 bfd_error = system_call_error;
233 /* nbfd has to point to head of malloc'ed block so that bfd_close may
234 reclaim it correctly. */
238 bfd_error = no_memory;
242 nbfd->filename = filename;
243 nbfd->xvec = target_vec;
244 nbfd->direction = write_direction;
246 if (bfd_open_file (nbfd) == NULL) {
247 bfd_error = system_call_error; /* File not writeable, etc */
248 (void) obstack_free (&nbfd->memory, (PTR)0);
256 /** Close up shop, get your deposit back. */
261 if (BFD_SEND (abfd, _close_and_cleanup, (abfd)) != true) return false;
263 bfd_cache_close(abfd);
264 /* If the file was open for writing and is now executable
266 if (abfd->direction == write_direction
267 && abfd->flags & EXEC_P) {
269 stat(abfd->filename, &buf);
270 chmod(abfd->filename,buf.st_mode | S_IXUSR | S_IXGRP | S_IXOTH);
272 (void) obstack_free (&abfd->memory, (PTR)0);
276 /* Create a bfd with no associated file or target. */
279 DEFUN(bfd_create,(filename, template),
280 CONST char *filename AND
283 bfd *nbfd = new_bfd();
284 if (nbfd == (bfd *)NULL) {
285 bfd_error = no_memory;
288 nbfd->filename = filename;
290 nbfd->xvec = template->xvec;
292 nbfd->direction = no_direction;
293 bfd_set_format(nbfd, bfd_object);
297 /* Memory allocation */
299 DEFUN(PTR bfd_alloc, (abfd, size),
303 PTR res = obstack_alloc(&(abfd->memory), (int)size);
307 DEFUN(PTR bfd_zalloc,(abfd, size),
311 PTR res = bfd_alloc(abfd, size);
312 memset(res, 0, (size_t)size);
316 DEFUN(PTR bfd_realloc,(abfd, old, size),
321 PTR res = bfd_alloc(abfd, size);
322 memcpy(res, old, (size_t)size);
327 DEFUN(bfd_size_type bfd_alloc_size,(abfd),
330 struct _obstack_chunk *chunk = abfd->memory.chunk;
333 size += chunk->limit - &(chunk->contents[0]);