Return to xusend.c CVS log

Up to [Research Unix] / researchv9 / cmd / emacs

Annotation of researchv9/cmd/emacs/xusend.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include <sys/types.h>
                      3: #include <sys/stat.h>
                      4: 
                      5: /* EMACS_MODES: c, !fill */
                      6: 
                      7: /* xusend -- Warren Montgomery  12/15/80 */
                      8: 
                      9: /* xusend  calls usend, segmenting the list files sent so that each
                     10:  * invocation of usend sends no more than 150,000 bytes.  This is a
                     11:  * temporary kludge, that really should be part of the standard
                     12:  * usend command. */
                     13: 
                     14: /* Usage is: 
                     15:  * 
                     16:  * xusend "usend args" <files>
                     17:  *
                     18:  */
                     19: 
                     20: char *usend = "usend ";                        /* program to call */
                     21: #define FLIMIT 100000
                     22: #define ALIMIT 160000
                     23: 
                     24: char combuf[2048];
                     25: 
                     26: char *
                     27: strcat(cp,cp1)
                     28: 
                     29: register char *cp;
                     30: register char *cp1;
                     31: {
                     32:        while (*cp++ = *cp1++);
                     33:        return(cp-1);
                     34: }
                     35: 
                     36: main(argc,argv)
                     37: 
                     38: int argc;
                     39: char **argv;
                     40: {
                     41:        long fbytes = 0;
                     42:        int filecount = 0;
                     43:        int status;
                     44:        struct stat statb;
                     45:        char *bufptr;
                     46:        char *savbuf;
                     47:        
                     48:        if (argc < 3) {
                     49:                printf ("Usage is:\n\n");
                     50:                printf ("xusend \"usend args\" <files>\n\n");
                     51:                exit(0);
                     52:        }
                     53:        
                     54:        savbuf = strcat(combuf,usend);
                     55:        savbuf=strcat(savbuf,argv[1]);
                     56:        argc-= 2;
                     57:        argv+= 2;
                     58:        
                     59:        while (argc>0) {
                     60:                
                     61:                
                     62:                                        /* process next block of files */
                     63:                
                     64:                bufptr = savbuf;
                     65:                fbytes = 0;
                     66:                filecount = 0;
                     67:                
                     68:                while (argc && (fbytes < FLIMIT)) {
                     69:                        status = stat(*argv,&statb);
                     70:                        if (status != 0) {
                     71:                                printf ("Can't stat %s, ignoring it\n", *argv);;
                     72:                                argv++;
                     73:                                argc--;
                     74:                        } else {
                     75:                                fbytes += statb.st_size;
                     76:                                if ((fbytes < FLIMIT) || (filecount == 0)){
                     77:                                        *bufptr++ = ' ';
                     78:                                        bufptr = strcat(bufptr,*argv);
                     79:                                        argv++;
                     80:                                        argc--;
                     81:                                        filecount++;
                     82:                                        if (fbytes >FLIMIT) {
                     83:                                                printf ("File %s may be to big for usend\n", *argv);
                     84:                                        }
                     85:                                }
                     86:                        }
                     87:                }
                     88:                if (filecount) {
                     89:                        printf("\n%s\n",combuf);
                     90:                        system (combuf);
                     91:                } else {
                     92:                        printf ("File %s is too big for usend, ignoring it\n", *argv);
                     93:                        argv++;
                     94:                        argc--;
                     95:                }
                     96:        }
                     97: }
                     98: 

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