Return to edit.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / quipu / dish

Annotation of 43BSDReno/contrib/isode-beta/quipu/dish/edit.c, revision 1.1

1.1     ! root        1: /* edit.c - */
        !             2: 
        !             3: #ifndef        lint
        !             4: static char *rcsid = "$Header: /f/osi/quipu/dish/RCS/edit.c,v 7.1 90/07/09 14:47:08 mrose Exp $";
        !             5: #endif
        !             6: 
        !             7: /* 
        !             8:  * $Header: /f/osi/quipu/dish/RCS/edit.c,v 7.1 90/07/09 14:47:08 mrose Exp $
        !             9:  *
        !            10:  *
        !            11:  * $Log:       edit.c,v $
        !            12:  * Revision 7.1  90/07/09  14:47:08  mrose
        !            13:  * sync
        !            14:  * 
        !            15:  * Revision 7.0  89/11/23  22:20:04  mrose
        !            16:  * Release 6.0
        !            17:  * 
        !            18:  */
        !            19: 
        !            20: /*
        !            21:  *                               NOTICE
        !            22:  *
        !            23:  *    Acquisition, use, and distribution of this module and related
        !            24:  *    materials are subject to the restrictions of a license agreement.
        !            25:  *    Consult the Preface in the User's Manual for the full terms of
        !            26:  *    this agreement.
        !            27:  *
        !            28:  */
        !            29: 
        !            30: 
        !            31: #include "manifest.h"
        !            32: #include "quipu/util.h"
        !            33: #include "psap.h"
        !            34: #include "tailor.h"
        !            35: #include <fcntl.h>
        !            36: #include <sys/stat.h>
        !            37: 
        !            38: extern char     fname[];
        !            39: 
        !            40: #define        OPT     (!frompipe || rps -> ps_byteno == 0 ? opt : rps)
        !            41: #define        RPS     (!frompipe || opt -> ps_byteno == 0 ? rps : opt)
        !            42: extern char    frompipe;
        !            43: extern PS      opt, rps;
        !            44: 
        !            45: editentry (argc, argv)
        !            46: int             argc;
        !            47: char          **argv;
        !            48: {
        !            49:        char            editbuf[LINESIZE];
        !            50: 
        !            51:        if (argc != 1) {
        !            52:                Usage (argv[0]);
        !            53:                return (NOTOK);
        !            54:        }
        !            55: 
        !            56:        (void) sprintf (editbuf, "%s %s",
        !            57:                        _isodefile (isodebinpath, "editentry"), fname);
        !            58: 
        !            59:        return (execprog (editbuf));
        !            60: }
        !            61: 
        !            62: 
        !            63: execprog (str)
        !            64: char           *str;
        !            65: {
        !            66:        char            prog[LINESIZE];
        !            67:        int             res;
        !            68:        extern char     inbuf[];
        !            69:        extern int      fd;
        !            70:        extern char     remote_prob;
        !            71: 
        !            72:        if (frompipe) {
        !            73: 
        !            74:                /* sleep (1) */ /* needed on startup ? */
        !            75: 
        !            76:                (void) sprintf (prog, "e%s", str);
        !            77: 
        !            78:                send_pipe_aux (prog);
        !            79: 
        !            80:                if ((res = read_pipe_aux (prog,LINESIZE)) < 1) {
        !            81:                        (void) fprintf (stderr, "read failure\n");
        !            82:                        remote_prob = TRUE;
        !            83:                        return (NOTOK);
        !            84:                } else {
        !            85:                        if (res == 0) {
        !            86:                                (void) fprintf (stderr, "read (0) failure\n");
        !            87:                                remote_prob = TRUE;
        !            88:                                return (NOTOK);
        !            89:                        }
        !            90:                        if ((res == 1) && (*prog == 'e')) {
        !            91:                                remote_prob = FALSE;
        !            92:                                return (NOTOK);  /* remote error - abandon ! */
        !            93:                        } 
        !            94:                        if (*fname != '/') {
        !            95:                                char            tempbuf[LINESIZE];
        !            96: 
        !            97:                                /* relative path... prefix cwd */
        !            98:                                *(prog + res) = 0;
        !            99:                                (void) sprintf (tempbuf, "%s/%s", prog, fname);
        !           100:                                (void) strcpy (fname, tempbuf);
        !           101:                        }
        !           102:                }
        !           103:        } else
        !           104:                if (system (str) != 0)
        !           105:                        return (NOTOK);
        !           106: 
        !           107:        return (OK);
        !           108: }
        !           109: 
        !           110: 
        !           111: get_password (str,buffer)
        !           112: char * str;
        !           113: char * buffer;
        !           114: {
        !           115: 
        !           116:        char            prog[LINESIZE];
        !           117:        int             res;
        !           118:        extern char     inbuf[];
        !           119:        extern int      fd;
        !           120:        extern char     remote_prob;
        !           121:        char *          getpassword ();
        !           122: 
        !           123:        if (frompipe) {
        !           124:                (void) sprintf (prog, "p%s", str);
        !           125: 
        !           126:                send_pipe_aux (prog);
        !           127: 
        !           128:                if ((res = read_pipe_aux (prog,LINESIZE)) < 1) {
        !           129:                        (void) fprintf (stderr, "read failure\n");
        !           130:                        remote_prob = TRUE;
        !           131:                        return;
        !           132:                } else {
        !           133:                        if (res == 0) {
        !           134:                                (void) fprintf (stderr, "read (0) failure\n");
        !           135:                                remote_prob = TRUE;
        !           136:                                return;
        !           137:                        }
        !           138:                        if ((res == 1) && (*prog == 'e')) {
        !           139:                                remote_prob = FALSE;
        !           140:                                return;
        !           141:                        } 
        !           142:                        *(prog+res) = 0;
        !           143:                        (void) strcpy (buffer, prog);
        !           144:                }
        !           145:        } else {
        !           146:                (void) sprintf (buffer,"Enter password for \"%s\": ",str);
        !           147:                (void) strcpy (buffer,getpassword (buffer));
        !           148:        }
        !           149: }
        !           150: 
        !           151: yesno (str)
        !           152: char * str;
        !           153: {
        !           154:        char            prog[LINESIZE];
        !           155:        int             res;
        !           156:        extern char     inbuf[];
        !           157:        extern int      fd;
        !           158:        extern char     remote_prob;
        !           159:        char *          getpassword ();
        !           160: 
        !           161:        if (frompipe) {
        !           162:                (void) sprintf (prog, "y%s", str);
        !           163: 
        !           164:                send_pipe_aux (prog);
        !           165: 
        !           166:                if ((res = read_pipe_aux (prog,LINESIZE)) < 1) {
        !           167:                        (void) fprintf (stderr, "read failure\n");
        !           168:                        remote_prob = TRUE;
        !           169:                        return FALSE;
        !           170:                } else {
        !           171:                        if (res == 0) {
        !           172:                                (void) fprintf (stderr, "read (0) failure\n");
        !           173:                                remote_prob = TRUE;
        !           174:                                return FALSE;
        !           175:                        }
        !           176:                        if ((res == 1) && (*prog == 'e')) {
        !           177:                                remote_prob = FALSE;
        !           178:                                return FALSE;
        !           179:                        } 
        !           180:                }
        !           181:        } else {
        !           182:                ps_printf (OPT,"%s",str);
        !           183:                (void) fgets (prog, sizeof prog, stdin);
        !           184:        }
        !           185: 
        !           186:        if (prog[0] == 'y')
        !           187:                return TRUE;
        !           188:        else
        !           189:                return FALSE;
        !           190: }

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