Open64: osprey/libI77/close.c Source File

00001 /*
00002 
00003   Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00004 
00005   This program is free software; you can redistribute it and/or modify it
00006   under the terms of version 2.1 of the GNU Lesser General Public License 
00007   as published by the Free Software Foundation.
00008 
00009   This program is distributed in the hope that it would be useful, but
00010   WITHOUT ANY WARRANTY; without even the implied warranty of
00011   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
00012 
00013   Further, this software is distributed without any warranty that it is
00014   free of the rightful claim of any third person regarding infringement 
00015   or the like.  Any license provided herein, whether implied or 
00016   otherwise, applies only to this software file.  Patent licenses, if
00017   any, provided herein do not apply to combinations of this program with 
00018   other software, or any other product whatsoever.  
00019 
00020   You should have received a copy of the GNU Lesser General Public 
00021   License along with this program; if not, write the Free Software 
00022   Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, 
00023   USA.
00024 
00025   Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00026   Mountain View, CA 94043, or:
00027 
00028   http://www.sgi.com
00029 
00030   For further information regarding this notice, see:
00031 
00032   http://oss.sgi.com/projects/GenInfo/NoticeExplan
00033 
00034 */
00035 
00036 
00037 
00038 /* $Header: /proj/osprey/CVS/open64/osprey1.0/libI77/close.c,v 1.1.1.1 2005/10/21 19:00:00 marcel Exp $ */
00039 /*  3.0 SID # 1.2 */
00040 
00041 /* who  ref.    date    description     */
00042 /* AGC  #587  28Jan87   return error on closing non-open unit   */
00043 /* SJC  #1668 12Oct87   undo bug fix 587 (violates ANSI std)    */
00044 /* sjc  #1963 11Dec87   Dynamically allocate unit table   */
00045 /* bcn    22Nov88   Add mp_cleanup to f_exit    */
00046 
00047 #include <sys/types.h>
00048 
00049 #include <string.h>
00050 #include <mutex.h>
00051 #include <stdio.h>
00052 #include <unistd.h>
00053 #include <stdlib.h>
00054 #include <cmplrs/fio.h>
00055 #include "fmt.h"
00056 #include "iomode.h"
00057 #include "idxio.h"
00058 #include "close.h"
00059 #include "err.h"
00060 #include "fio_direct_io.h"
00061 #include "util.h"
00062 #include "bcompat.h"
00063 #include "cmplrs/f_errno.h"
00064 
00065 extern void __checktraps(void);
00066 
00067 
00068 /* forward declaration */
00069 static ftnint
00070 f_clos_com (cllist *a, int lock) ;
00071 
00072 ftnint
00073 f_clos (cllist *a) 
00074 {
00075     return( f_clos_com( a, 0 ) );
00076 }
00077 
00078 ftnint
00079 f_clos64_mp (cllist *a) 
00080 {
00081     return( f_clos_com( a, 1 ) );
00082 }
00083 
00084 
00085 
00086 static ftnint
00087 f_clos_com (cllist *a, int lock) 
00088 {
00089    unit           *ftnunit;
00090    char           *cbuf, c, buf[256], tbuf[12];
00091    int       n, istat;
00092 
00093    if ((ftnunit = find_luno (a->cunit)) == NULL) {
00094       return 0;
00095    }
00096    while (lock && test_and_set( &ftnunit->lock_unit, 1L ))
00097        ;
00098    if (ftnunit->uconn <= 0) {
00099        /* could be disconnected by other threads */
00100        ftnunit->uconn = 0;
00101        ftnunit->lock_unit = 0;
00102        return(0);
00103    }
00104    ftnunit->uend = 0;
00105    if (cbuf = a->csta)
00106       switch (up_low (*cbuf++)) {
00107       case 'd':
00108    ftnunit->udisp = DELETE;
00109    break;
00110       case 'p':
00111    ftnunit->udisp = PRINT;
00112    goto checkdelete;
00113 
00114 /*
00115  * Fix BN 7869.
00116  * This is very sloppy code for checking the specifiers to close. Currently
00117  * both DISP and STATUS cannot be used as specifiers to close. This is a kludge
00118  * that allows SAVE to be passed and treats it like KEEP instead of SUBMIT.
00119  * ---ravi---   10/30/91
00120  *    case 's':  ftnunit->udisp = SUBMIT;
00121  */
00122       case 's':
00123    ftnunit->udisp = up_low (*cbuf) == 'a' ? KEEP : SUBMIT;
00124    checkdelete:
00125    while (c = (*cbuf++))
00126       if ((c == '/') && (c = (*cbuf)) && (up_low (c) == 'd'))
00127          ftnunit->udisp |= DELETE;
00128    break;
00129 
00130      case 'k':
00131    if (ftnunit->uscrtch == 1)
00132      err(a->cerr, F_ERKEEPSCRATCH, "close");
00133      default:
00134    ftnunit->udisp = KEEP;
00135       }
00136    if (ftnunit->uscrtch == 1)
00137       ftnunit->udisp |= DELETE;
00138    if (ftnunit->uacc == KEYED) {
00139       n = idxclose(ftnunit, a->cerr);
00140       ftnunit->lock_unit = 0;
00141       return (n);
00142    }
00143 
00144 #ifdef I90
00145    /* If in Fortran-90 nonadvancing mode, write endfile record (\n only). */
00146    if ( (ftnunit->f90sw == 1) && (ftnunit->f90nadv == 1) && (ftnunit->uwrt & WR_OP) ) {
00147   putc ('\n', ftnunit->ufd);
00148   ftnunit->f90nadv = 0;
00149    }
00150 #endif
00151 
00152    if (ftnunit->ucc == CC_FORTRAN && ftnunit->ucchar)
00153       putc (ftnunit->ucchar, ftnunit->ufd);
00154 
00155    if (ftnunit->ufd == stdin || ftnunit->ufd == stdout || ftnunit->ufd == stderr) {
00156      /* 
00157       * Don't close stdin, stdout, and stderr otherwise other files
00158       * can be opened using those pointers and caused a lot of confusion
00159       */
00160       fflush(ftnunit->ufd);
00161       goto cont;
00162    }
00163    if (ftnunit->uwrt & WR_OP)
00164       (void) t_runc (ftnunit, a->cerr);
00165 
00166    /* Close the file. */
00167 
00168    if ((ftnunit->uacc == DIRECT) && (ftnunit->ufmt == 0)) { /* direct unformatted */
00169       while (lock && test_and_set( &io_lock, 1L ))
00170          ;
00171       if (ftnunit->uistty) {
00172    _fio_du_close ((int) ftnunit->ufd);  /* no error */
00173       } else if (((int)ftnunit->ufd) !=  _fio_du_close ((int) ftnunit->ufd)) {
00174    io_lock = 0;
00175          if (lock) ftnunit->lock_unit = 0;
00176    err (a->cerr, errno, "close");
00177       }
00178       io_lock = 0;
00179    } else {
00180       if (ftnunit->uistty) {    /* have to call isatty() first to get
00181          * correct result */
00182       /* obtain exclusive lock for special I/O operation */
00183       while (lock && test_and_set( &io_lock, 1L ))
00184          ;
00185       istat = fclose (ftnunit->ufd);
00186       io_lock = 0;
00187       } else {
00188    /* obtain exclusive lock for special I/O operation */
00189    while (lock && test_and_set( &io_lock, 1L ))
00190       ;
00191    istat = fclose (ftnunit->ufd);
00192    io_lock = 0;
00193    if (istat) {
00194             if (lock) ftnunit->lock_unit = 0;
00195       err (a->cerr, errno, "close");
00196    }
00197       }
00198    }
00199 
00200    if (ftnunit->ufnm) {
00201       if (ftnunit->udisp & SUBMIT) {
00202    (void) strcpy (tbuf, "tmp.FXXXXXX");
00203    (void) mktemp (tbuf);
00204    sprintf (buf, "cp %s %s", ftnunit->ufnm, tbuf);
00205    system (buf);
00206    sprintf (buf, "( chmod +x %s; %s; rm %s ) &",
00207       tbuf, tbuf, tbuf);
00208    system (buf);
00209       } else if (ftnunit->udisp & PRINT) {
00210    sprintf (buf, "lpr %s", ftnunit->ufnm);
00211    system (buf);
00212       }
00213       if (ftnunit->udisp & DELETE)
00214    (void) unlink (ftnunit->ufnm); /* SYSDEP */
00215       free (ftnunit->ufnm);
00216       ftnunit->ufnm = NULL;
00217    }
00218 cont:
00219    /*
00220      The following fixes bug #231656.  The pointers involved are initialized
00221      to zero (both when originally allocated in f_init() and when reallocated
00222      in map_luno()).  So, if non-zero, the buffers must have been allocated,
00223      and we should free them.
00224    */
00225    if (ftnunit->f77syl) {
00226     free(ftnunit->f77syl);
00227     ftnunit->f77syl = NULL;
00228    }
00229    if (ftnunit->f77fio_buf) {
00230     free(ftnunit->f77fio_buf);
00231     ftnunit->f77fio_buf = NULL;
00232     ftnunit->f77fio_size = 0;
00233    }
00234    if (ftnunit->ukeys) {
00235     free(ftnunit->ukeys);
00236     ftnunit->ukeys = NULL;
00237    }
00238    ftnunit->ufd = NULL;
00239    ftnunit->uconn = 0;
00240    ftnunit->luno = 0;
00241    if (lock) ftnunit->lock_unit = 0;
00242    /* added in MIPS version 2.20 fix bug 6084 BN-8077. Undo 6084 fix */
00243    return (0);
00244 }
00245 
00246 #ifdef BUG_6084
00247 /* fix bug 6084 
00248 **ftnint
00249 **f_clos2 (cllist *a) {
00250 **   unit           *ftnunit;
00251 **   char           *cbuf, c, buf[256], tbuf[12];
00252 **   int       n, istat;
00253 **
00254 **   if ((ftnunit = map_luno (a->cunit)) == NULL) {
00255 **      return 0;
00256 **   }
00257 **   while (lock && test_and_set( &ftnunit->lock_unit, 1L ))
00258 **       ;
00259 **   if (ftnunit->uconn <= 0) {
00260 **      return 0;
00261 **   }
00262 **   ftnunit->uend = 0;
00263 **   if (cbuf = a->csta)
00264 **      switch (up_low (*cbuf++)) {
00265 **      case 'd':
00266 **   ftnunit->udisp = DELETE;
00267 **   break;
00268 **
00269 **      case 'p':
00270 **   ftnunit->udisp = PRINT;
00271 **   goto checkdelete;
00272 **
00273 **      case 's':
00274 **   ftnunit->udisp = SUBMIT;
00275 **   checkdelete:
00276 **   while (c = (*cbuf++))
00277 **      if ((c == '/') && (c = (*cbuf)) && (up_low (c) == 'd'))
00278 **         ftnunit->udisp |= DELETE;
00279 **   break;
00280 **      default:
00281 **   ftnunit->udisp = KEEP;
00282 **      }
00283 **   if (ftnunit->uscrtch == 1)
00284 **      ftnunit->udisp |= DELETE;
00285 **   if (ftnunit->uacc == KEYED) {
00286 **      n = idxclose(ftnunit, a->cerr);
00287 **      return (n);
00288 **   }
00289 **   if (ftnunit->ucc == CC_FORTRAN && ftnunit->ucchar)
00290 **      putc (ftnunit->ucchar, ftnunit->ufd);
00291 **   if (ftnunit->uwrt)
00292 **      (void) t_runc (ftnunit, a->cerr);
00293 **
00294 **
00295 **   if ((ftnunit->ufd != stdin) && (ftnunit->ufd != stdout) && (ftnunit->ufd != stderr)) {
00296 **      if (ftnunit->uacc == DIRECT) {
00297 **   if (ftnunit->uistty) {
00298 **      _fio_du_close ((int) ftnunit->ufd);
00299 **   } else if (ftnunit->ufd != (FILE *) _fio_du_close ((int) ftnunit->ufd)) {
00300 **      err (a->cerr, errno, "close");
00301 **   }
00302 **      } else {
00303 **   if (ftnunit->uistty) { 
00304 **      fclose (ftnunit->ufd);
00305 **   } else if (fclose (ftnunit->ufd) != 0) {
00306 **      err (a->cerr, errno, "close");
00307 **   }
00308 **      }
00309 **   }
00310 **   if (ftnunit->ufnm) {
00311 **      if (ftnunit->udisp & SUBMIT) {
00312 **   (void) strcpy (tbuf, "tmp.FXXXXXX");
00313 **   (void) mktemp (tbuf);
00314 **   sprintf (buf, "cp %s %s", ftnunit->ufnm, tbuf);
00315 **   system (buf);
00316 **   sprintf (buf, "( chmod +x %s; %s; rm %s ) &",
00317 **      tbuf, tbuf, tbuf);
00318 **   system (buf);
00319 **      } else if (ftnunit->udisp & PRINT) {
00320 **   sprintf (buf, "lpr %s", ftnunit->ufnm);
00321 **   system (buf);
00322 **      }
00323 **      if (ftnunit->udisp & DELETE)
00324 **   (void) unlink (ftnunit->ufnm); 
00325 **      free (ftnunit->ufnm);
00326 **   }
00327 **   if (ftnunit->f77syl) {
00328 **    free(ftnunit->f77syl);
00329 **    ftnunit->f77syl = NULL;
00330 **   }
00331 **   if (ftnunit->f77fio_buf) {
00332 **    free(ftnunit->f77fio_buf);
00333 **    ftnunit->f77fio_buf = NULL;
00334 **    ftnunit->f77fio_size = 0;
00335 **   }
00336 **   if (ftnunit->ukeys) {
00337 **    free(ftnunit->ukeys);
00338 **    ftnunit->ukeys = NULL;
00339 **   }
00340 **   ftnunit->ufnm = NULL;
00341 **   ftnunit->ufd = NULL;
00342 **   ftnunit->uconn = NULL;
00343 **   ftnunit->luno = 0;
00344 **   return (0);
00345 **}
00346 */
00347 #endif
00348 
00349 void
00350 f_exit ()
00351 {
00352    int             i;
00353    cllist          xx;
00354 
00355    /* trap handler : print the count upon exit of the program, if
00356     * enabled */
00357    __checktraps ();
00358    xx.cerr = 1;
00359    xx.csta = NULL;
00360    for (i = 0; i < mxunit; i++) { /* sjc #1963 11Dec 87 */
00361       xx.cunit = f77units[i].luno;
00362       if (xx.cunit > 0)   /* don't close the artificial LU created
00363            for internal file I/O */
00364   /* Since other threads could be exitting and closing the files
00365   ** at the same time, make sure they don't step on each others
00366   */
00367         (void) f_clos64_mp (&xx);
00368    }
00369 }
00370 
00371 
00372 /* Truncate a file using ftruncate rather than fork/exec of /bin/cp.
00373   #1951 sjc 10Dec87 */
00374 ftnint
00375 t_runc (unit *ftnunit, flag xerr) {
00376    extern void     exit();  /* DAG -- added */
00377 #if 0 /* not used. */
00378    char            buf[128], nm[16];
00379    FILE           *tmp;
00380    int             n, m;
00381    int             fd;
00382 #endif
00383 
00384 #ifdef _BSD
00385    off_t           ftell();
00386 
00387 #endif        /* _BSD */
00388 #if defined  (_SYSV) || defined(_SYSTYPE_SVR4)
00389 #ifndef sgi
00390    long            ftell();
00391 
00392 #endif
00393 #endif        /* SYSV */
00394 
00395    ftnll            loc, len;
00396 
00397    if (ftnunit->uacc == DIRECT)
00398       return (0);   /* don't truncate direct files */
00399 
00400    if (ftnunit->useek == 0 || ftnunit->ufnm == NULL)
00401       return (0);
00402 
00403    /* do not truncate "/dev/null" */
00404    if (strncmp("/dev/null", ftnunit->ufnm, 9) == 0)
00405       return (0);
00406 
00407    loc = FTELL (ftnunit->ufd);
00408    (void) fseek (ftnunit->ufd, 0L, 2);
00409    len = FTELL (ftnunit->ufd);
00410    /* if ftell() fails then ignore the pipe/device */
00411    if (loc == len || loc < 0)
00412       return (0);
00413    if (TRUNCATE (ftnunit->ufnm, loc))
00414       err (xerr, 111, "endfile");
00415    (void) FSEEK (ftnunit->ufd, loc, 0);
00416    return 0;
00417 }
00418 
00419 #pragma weak f_clos64 = f_clos