Return to myfopen.c CVS log

Up to [Research Unix] / researchv10no / lbin / mailx

Annotation of researchv10no/lbin/mailx/myfopen.c, revision 1.1.1.1

1.1       root        1: #ident "@(#)myfopen.c  1.3 'attmail mail(1) command'"
                      2: #ident "@(#)mailx:myfopen.c    1.1"
                      3: /*     Copyright (c) 1988 AT&T */
                      4: /*       All Rights Reserved   */
                      5: 
                      6: /*     THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T     */
                      7: /*     The copyright notice above does not evidence any        */
                      8: /*     actual or intended publication of such source code.     */
                      9: 
                     10: #ident "@(#)mailx:myfopen.c    1.0"
                     11: 
                     12: #include "rcv.h"
                     13: 
                     14: #undef fopen
                     15: #undef fclose
                     16: 
                     17: /*
                     18:  * mailx -- a modified version of a University of California at Berkeley
                     19:  *     mail program
                     20:  *
                     21:  * Local version of fopen() and fclose(). These maintain a list of
                     22:  * file pointers which can be run down when we need to close
                     23:  * all files, such as before executing external commands.
                     24:  */
                     25: 
                     26: static NODE    *append();
                     27: static NODE    *del1();
                     28: static NODE    *getnode();
                     29: static NODE    *search();
                     30: 
                     31: static NODE *
                     32: getnode(fp)
                     33: FILE *fp;
                     34: {
                     35:        NODE *new;
                     36: 
                     37:        if ((new = (NODE *)malloc(sizeof(NODE))) == (NODE *)NULL) {
                     38:                (void) fputs("Cannot allocate node space\n", stderr);
                     39:                exit(3);
                     40:        }
                     41:        new->fp = fp;
                     42:        new->next = (NODE *)NULL;
                     43:        return(new);
                     44: }
                     45: 
                     46: static NODE *
                     47: search(fp)
                     48: FILE *fp;
                     49: {
                     50:        register NODE *tmp;
                     51:        
                     52:        for (tmp = fplist; tmp != (NODE *)NULL; tmp = tmp->next)
                     53:                if (tmp->fp == fp)
                     54:                        break;
                     55:        return( tmp != (NODE *)NULL ? tmp : NOFP);
                     56: }
                     57:        
                     58: static NODE *
                     59: append(fp)
                     60: FILE *fp;
                     61: {
                     62:        register NODE *new;
                     63: 
                     64:        if ((new = getnode(fp)) == (NODE *)NULL)
                     65:                return(NOFP);
                     66:        if (fplist == NOFP) {
                     67:                fplist = new;
                     68:        } else {
                     69:                new->next = curptr->next;
                     70:                curptr->next = new;
                     71:        }
                     72:        return(new);
                     73: }
                     74: 
                     75: static NODE *
                     76: del1(oldcur)
                     77: NODE *oldcur;
                     78: {
                     79:        register NODE *cur, *prev;
                     80: 
                     81:        for (prev = cur = fplist; cur != (NODE *)NULL; cur = cur->next) {
                     82:                if (cur == oldcur) {
                     83:                        if (cur == fplist) {
                     84:                                cur = fplist = cur->next;
                     85:                        } else {
                     86:                                prev->next = cur->next;
                     87:                                cur = prev->next ? prev->next : prev;
                     88:                        }
                     89:                        free(oldcur);
                     90:                        break;
                     91:                }
                     92:                prev = cur;
                     93:        }
                     94:        return(cur);
                     95: }
                     96: 
                     97: FILE *
                     98: my_fopen(file, mode)
                     99: char   *file, *mode;
                    100: {
                    101:        FILE *fp;
                    102: 
                    103:        if ((fp = fopen(file, mode)) == (FILE *)NULL) {
                    104:                fplist = NOFP;
                    105:                return(fp);
                    106:        } else {
                    107:                curptr = append(fp);
                    108:        }
                    109:        return(fp);
                    110: }
                    111: 
                    112: int
                    113: my_fclose(iop)
                    114: register FILE *iop;
                    115: {
                    116:        register NODE *cur;
                    117: 
                    118:        int ret = fclose(iop);
                    119:        if (fplist != NOFP) {
                    120:                cur = search(iop);
                    121:                cur = del1(cur);
                    122:        }
                    123:        return ret;
                    124: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.