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?... */
56 #define obstack_chunk_alloc malloc
57 #define obstack_chunk_free free
59 /* Return a new BFD. All BFD's are allocated through this routine. */
65 obstack_begin(&tmp,128);
67 nbfd = (bfd *)obstack_alloc(&tmp,sizeof(bfd));
68 memset((PTR)nbfd, 0, sizeof (bfd)); /* Clear it */
72 nbfd->direction = no_direction;
73 nbfd->iostream = NULL;
75 nbfd->sections = (asection *)NULL;
76 nbfd->format = bfd_unknown;
77 nbfd->my_archive = (bfd *)NULL;
79 nbfd->opened_once = false;
80 nbfd->output_has_begun = false;
81 nbfd->section_count = 0;
82 nbfd->usrdata = (PTR)NULL;
83 nbfd->sections = (asection *)NULL;
84 nbfd->cacheable = false;
85 nbfd->flags = NO_FLAGS;
90 /* Allocate a new BFD as a member of archive OBFD. */
92 bfd *new_bfd_contained_in(obfd)
95 bfd *nbfd = new_bfd();
96 nbfd->xvec = obfd->xvec;
97 nbfd->my_archive = obfd;
98 nbfd->direction = read_direction;
102 /** bfd_openr, bfd_fdopenr -- open for reading.
103 Returns a pointer to a freshly-allocated bfd on success, or NULL. */
106 DEFUN(bfd_openr, (filename, target),
107 CONST char *filename AND
111 bfd_target *target_vec;
113 target_vec = bfd_find_target (target);
114 if (target_vec == NULL) {
115 bfd_error = invalid_target;
119 bfd_error = system_call_error;
122 bfd_error = no_memory;
126 nbfd->filename = filename;
127 nbfd->xvec = target_vec;
128 nbfd->direction = read_direction;
130 if (bfd_open_file (nbfd) == NULL) {
131 bfd_error = system_call_error; /* File didn't exist, or some such */
139 /* Don't try to `optimize' this function:
141 o - We lock using stack space so that interrupting the locking
142 won't cause a storage leak.
143 o - We open the file stream last, since we don't want to have to
144 close it if anything goes wrong. Closing the stream means closing
145 the file descriptor too, even though we didn't open it.
149 DEFUN(bfd_fdopenr,(filename, target, fd),
150 CONST char *filename AND
151 CONST char *target AND
155 bfd_target *target_vec;
158 struct flock lock, *lockp = &lock;
161 target_vec = bfd_find_target (target);
162 if (target_vec == NULL) {
163 bfd_error = invalid_target;
167 bfd_error = system_call_error;
169 fdflags = fcntl (fd, F_GETFL);
170 if (fdflags == -1) return NULL;
173 lockp->l_type = F_RDLCK;
174 if (fcntl (fd, F_SETLKW, lockp) == -1) return NULL;
180 bfd_error = no_memory;
184 nbfd->lock = (struct flock *) (nbfd + 1);
186 /* if the fd were open for read only, this still would not hurt: */
187 nbfd->iostream = (char *) fdopen (fd, "r+");
188 if (nbfd->iostream == NULL) {
189 (void) obstack_free (&nbfd->memory, (PTR)0);
193 /* OK, put everything where it belongs */
195 nbfd->filename = filename;
196 nbfd->xvec = target_vec;
198 /* As a special case we allow a FD open for read/write to
199 be written through, although doing so requires that we end
200 the previous clause with a preposition. */
201 switch (fdflags & O_ACCMODE) {
202 case O_RDONLY: nbfd->direction = read_direction; break;
203 case O_WRONLY: nbfd->direction = write_direction; break;
204 case O_RDWR: nbfd->direction = both_direction; break;
209 memcpy (nbfd->lock, lockp, sizeof (struct flock))
212 bfd_cache_init (nbfd);
217 /** bfd_openw -- open for writing.
218 Returns a pointer to a freshly-allocated bfd on success, or NULL.
220 See comment by bfd_fdopenr before you try to modify this function. */
223 DEFUN(bfd_openw,(filename, target),
224 CONST char *filename AND
228 bfd_target *target_vec;
230 target_vec = bfd_find_target (target);
231 if (target_vec == NULL) return NULL;
233 bfd_error = system_call_error;
235 /* nbfd has to point to head of malloc'ed block so that bfd_close may
236 reclaim it correctly. */
240 bfd_error = no_memory;
244 nbfd->filename = filename;
245 nbfd->xvec = target_vec;
246 nbfd->direction = write_direction;
248 if (bfd_open_file (nbfd) == NULL) {
249 bfd_error = system_call_error; /* File not writeable, etc */
250 (void) obstack_free (&nbfd->memory, (PTR)0);
258 /** Close up shop, get your deposit back. */
263 if (BFD_SEND (abfd, _close_and_cleanup, (abfd)) != true) return false;
265 bfd_cache_close(abfd);
266 /* If the file was open for writing and is now executable
268 if (abfd->direction == write_direction
269 && abfd->flags & EXEC_P) {
271 stat(abfd->filename, &buf);
272 chmod(abfd->filename,buf.st_mode | S_IXUSR | S_IXGRP | S_IXOTH);
274 (void) obstack_free (&abfd->memory, (PTR)0);
278 /* Create a bfd with no associated file or target. */
281 DEFUN(bfd_create,(filename, template),
282 CONST char *filename AND
285 bfd *nbfd = new_bfd();
286 if (nbfd == (bfd *)NULL) {
287 bfd_error = no_memory;
290 nbfd->filename = filename;
292 nbfd->xvec = template->xvec;
294 nbfd->direction = no_direction;
295 bfd_set_format(nbfd, bfd_object);
299 /* Memory allocation */
301 DEFUN(PTR bfd_alloc, (abfd, size),
305 PTR res = obstack_alloc(&(abfd->memory), (int)size);
309 DEFUN(PTR bfd_zalloc,(abfd, size),
313 PTR res = bfd_alloc(abfd, size);
314 memset(res, 0, (size_t)size);
318 DEFUN(PTR bfd_realloc,(abfd, old, size),
323 PTR res = bfd_alloc(abfd, size);
324 memcpy(res, old, (size_t)size);
329 DEFUN(bfd_size_type bfd_alloc_size,(abfd),
332 struct _obstack_chunk *chunk = abfd->memory.chunk;
335 size += chunk->limit - &(chunk->contents[0]);