Annotation of 43BSDTahoe/new/xns/examples/print/getprintstatus.c, revision 1.1.1.1

1.1       root        1: /* $Header: getprintstatus.c,v 2.1 87/01/14 13:12:50 ed Exp $ */
                      2: 
                      3: /*
                      4:  * $Log:       getprintstatus.c,v $
                      5:  * Revision 2.1  86/10/11  15:42:11  jqj
                      6:  * Some convenience changes from B Jackson @ PARC
                      7:  * 
                      8:  * Revision 2.0  85/11/21  07:23:10  jqj
                      9:  * 4.3BSD standard release
                     10:  * 
                     11:  * Revision 1.1  85/11/20  13:56:47  jqj
                     12:  * Initial revision
                     13:  * 
                     14:  */
                     15: #include <stdio.h>
                     16: #include <sys/types.h>
                     17: #include <netns/ns.h>
                     18: #include "Printing3_defs.h"
                     19: #include <xnscourier/Clearinghouse2.h>
                     20: #include <xnscourier/except.h>
                     21: 
                     22: main(argc, argv)
                     23:        int argc;
                     24:        char *argv[];
                     25: {
                     26:        GetPrinterStatusResults result;
                     27:        struct ns_addr *destaddr;
                     28:        CourierConnection *conn;
                     29:        char *xnshost;
                     30:        extern struct ns_addr *getXNSaddr();
                     31:        extern struct ns_addr *CH_LookupAddr();
                     32:        Clearinghouse2_Name hostname;
                     33:        Clearinghouse2_Name defaultname;
                     34:        extern Clearinghouse2_Name CH_StringToName();
                     35:        extern char *getenv();
                     36: 
                     37:        CH_NameDefault(&defaultname);
                     38:        xnshost = getenv("PRINTER");
                     39:        switch (argc) {
                     40:        case 2: xnshost = argv[1];
                     41:        case 1: hostname = CH_StringToName(xnshost,&defaultname);
                     42:                if ((destaddr = CH_LookupAddr(hostname)) != NULL)
                     43:                        break;          /* got a valid host name */
                     44:                else
                     45:                        fprintf(stderr,"Invalid machine name: [%s:%s:%s]\n",
                     46:                                hostname.object,
                     47:                                hostname.domain,
                     48:                                hostname.organization);
                     49:        default:
                     50:                fprintf(stderr,"Usage: %s [machine]\n",argv[0]);
                     51:                exit(1);
                     52:        }
                     53: 
                     54:        if ((conn = CourierOpen(destaddr)) == NULL) {
                     55:                fprintf(stderr,"Can't open connection to %s\n",xnshost);
                     56:                exit(1);
                     57:        }
                     58: 
                     59:        DURING
                     60:                result = GetPrinterStatus(conn,NULL);
                     61:        HANDLER {
                     62:                switch (Exception.Code) {
                     63:                case ServiceUnavailable:
                     64:                        fprintf(stderr,"Service unavailable\n");
                     65:                        break;
                     66:                case SystemError:
                     67:                        fprintf(stderr,"System Error\n");
                     68:                        break;
                     69:                case Undefined:
                     70:                        fprintf(stderr,"Undefined error, number %d\n",
                     71:                                CourierErrArgs(UndefinedArgs,problem));
                     72: 
                     73:                case REJECT_ERROR:
                     74:                        fprintf(stderr,"REJECT:  type = %d\n",
                     75:                                CourierErrArgs(rejectionDetails, designator));
                     76:                        break;
                     77:                default:
                     78:                        fprintf(stderr,"Some random error, code %d\n",
                     79:                                Exception.Code);
                     80:                        break;
                     81:                }
                     82:        exit(1);
                     83:        } END_HANDLER;
                     84: 
                     85:        CourierClose(conn);
                     86:        printf("[%s:%s:%s]\n",
                     87:                hostname.object,
                     88:                hostname.domain,
                     89:                hostname.organization);
                     90:        printresults(result.status);
                     91: }
                     92: 
                     93: printresults(status)
                     94:        PrinterStatus status;
                     95: {
                     96:        int i, typ;
                     97:        static char *spoollist[] = {"available","busy","disabled","full"};
                     98:        static char *formatlist[] = {"available","busy","disabled"};
                     99:        static char *printlist[] = {"available","busy","disabled",
                    100:                        "needs attention","needs key operator"};
                    101: 
                    102:        for (i = 0; i < status.length; i++) {
                    103:                switch (status.sequence[i].designator) {
                    104:                case spooler:
                    105:                        typ = (int) status.sequence[i].spooler_case;
                    106:                        printf("Spooling status:  %s\n", spoollist[typ]);
                    107:                        break;
                    108:                case formatter:
                    109:                        typ = (int) status.sequence[i].formatter_case;
                    110:                        printf("Formatting status:  %s\n", formatlist[typ]);
                    111:                        break;
                    112:                case printer:
                    113:                        typ = (int) status.sequence[i].printer_case;
                    114:                        printf("Printer status:  %s\n", printlist[typ]);
                    115:                        break;
                    116:                case media:
                    117:                        printmedia(status.sequence[i].media_case);
                    118:                        break;
                    119:                }
                    120:        }
                    121: }
                    122: 
                    123: printmedia(media)
                    124:        Media media;
                    125: {
                    126:        int j;
                    127:        for (j = 0; j <media.length; j++) {
                    128:                switch (media.sequence[j].designator) {
                    129:                case paper:
                    130:                        printf("Paper #%d:  ", j+1);
                    131:                        printpaper(media.sequence[j].paper_case);
                    132:                        break;
                    133:                default:
                    134:                        printf("Unknown medium type\n");
                    135:                        break;
                    136:                }
                    137:        }
                    138: }
                    139: 
                    140: printpaper(paper)
                    141:        Paper paper;
                    142: {
                    143:        switch (paper.designator) {
                    144:        case unknown:
                    145:                printf("unknown\n");
                    146:                break;
                    147:        case knownSize:
                    148:                switch (paper.knownSize_case) {
                    149:                case usLetter:
                    150:                        printf("US letter\n");
                    151:                        break;
                    152:                case usLegal:
                    153:                        printf("US legal\n");
                    154:                        break;
                    155:                default:
                    156:                        printf("known size %d\n", paper.knownSize_case);
                    157:                        break;
                    158:                }
                    159:                break;
                    160:        case otherSize:
                    161:                printf("\tother size: width = %dmm, length = %d mm\n",
                    162:                        paper.otherSize_case.width,
                    163:                        paper.otherSize_case.length);
                    164:                break;
                    165:        default:
                    166:                printf("Unknown paper type");
                    167:                break;
                    168:        }
                    169: }

unix.superglobalmegacorp.com

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