![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to server.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / xns / xnslib|
Return to server.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / xns / xnslib |
1.1 root 1: /*
2: * This file implements server functions for the XNS courier library
3: */
4:
5: /*
6: $Log: server.c,v $
7: * Revision 2.2 86/12/10 14:21:10 ed
8: * Reset _serverConnection->abortseen in ReceiveCallMessage
9: *
10: * Revision 2.1 86/11/11 09:33:42 jqj
11: * In ReceiveCallMessage, set state to inprogress so server BDT will work
12: * right.
13: *
14: * Revision 2.0 85/11/21 07:22:19 jqj
15: * 4.3BSD standard release
16: *
17: * Revision 1.3 85/03/11 16:37:39 jqj
18: * *** empty log message ***
19: *
20: * Revision 1.3 85/03/11 16:37:39 jqj
21: * Public alpha-test version, released 11 March 1985
22: *
23: * Revision 1.2 85/01/27 07:37:43 jqj
24: * finished but undebugged version
25: *
26: * Revision 1.1 85/1/4 2:40:00 jqj
27: * Initial revision -- Mogul's tcp-based version
28: */
29: #ifndef lint
30: static char rcsid[] = "$Header: server.c,v 2.2 86/12/10 14:21:10 ed Exp $";
31: #endif
32:
33: #include <stdio.h>
34: #include <sys/time.h>
35: #include <sys/types.h> /* for ns.h */
36: #include <sys/socket.h>
37: #include <netns/ns.h> /* for XNS addresses and courierconnectin.h */
38: #include <netns/sp.h> /* for spphdr */
39: #include "courier.h"
40: #include "realcourierconnection.h"
41: #include <except.h>
42: #include <ctype.h>
43:
44: #if DEBUG
45: int CourierServerDebuggingFlag = 0;
46: #endif
47:
48: /*
49: * Message stream handle.
50: */
51: CourierConnection *_serverConnection = 0;
52: Unspecified tid; /* transaction ID */
53:
54:
55: /* CALL, transaction id, prognumh, prognuml, version, procedurenum */
56: #define CALLHDRLEN 6
57:
58:
59: Unspecified *
60: ReceiveCallMessage(procp, skipcount, skippedwords)
61: Cardinal *procp;
62: int skipcount;
63: Unspecified *skippedwords;
64: {
65: Cardinal msgtype, version;
66: LongCardinal programnumber;
67: Unspecified *buf, *bp, hdrbuf[CALLHDRLEN];
68: int i;
69:
70: if (skipcount > 1 && _serverConnection->state == wantversion) {
71: skipcount -= 2;
72: _serverConnection->state = inprogress; /* per Ed Flint */
73: skippedwords += 2;
74: }
75:
76: if (skipcount > CALLHDRLEN) {
77: fprintf(stderr,"ReceiveCallMessage: skipcount=%d, too big\n",
78: skipcount);
79: exit(1);
80: }
81:
82: _serverConnection->abortseen= FALSE; /* reset */
83:
84: for (i=0; i < skipcount; i++)
85: hdrbuf[i] = skippedwords[i];
86: buf = ReadMessage(_serverConnection, hdrbuf+skipcount,
87: CALLHDRLEN-skipcount);
88: bp = hdrbuf;
89: bp += internalize_Cardinal(&msgtype, bp);
90: bp += internalize_Unspecified(&tid, bp);
91: bp += internalize_LongCardinal(&programnumber, bp);
92: bp += internalize_Cardinal(&version, bp);
93: bp += internalize_Cardinal(procp, bp);
94: #if DEBUG
95: if (CourierServerDebuggingFlag)
96: fprintf(stderr, "[ReceiveCallMessage %D %d %d]\n",
97: programnumber, version, *procp);
98: #endif
99: return(buf);
100: }
101:
102:
103: SendReturnMessage(nwords, results)
104: Cardinal nwords;
105: Unspecified *results;
106: {
107: #define RETHDRLEN 2
108: Unspecified *bp, buf[RETHDRLEN];
109: static Cardinal msgtype = RETURN;
110:
111: #if DEBUG
112: if (CourierServerDebuggingFlag)
113: fprintf(stderr, "[SendReturnMessage %d]\n", nwords);
114: #endif
115: bp = buf;
116: bp += externalize_Cardinal(&msgtype, bp);
117: bp += externalize_Unspecified(&tid, bp);
118: CourierWrite(_serverConnection, (bp-buf), buf, nwords, results);
119: _serverConnection->bdtstate = wantdata;
120: }
121:
122:
123: static int
124: ServerInit(argc, argv, skippedwords)
125: int argc;
126: char *argv[];
127: Unspecified skippedwords[];
128: {
129: extern char *malloc();
130: int skipcount;
131: #if DEBUG
132: int namelen;
133: #endif
134: int i;
135:
136: _serverConnection = (CourierConnection *)
137: malloc(sizeof(CourierConnection));
138: _serverConnection->bdtstate = wantdata;
139: /* we normally don't bother to set up host, since the server will
140: * never reopen a closed connection
141: */
142: #if DEBUG
143: namelen = sizeof(struct sockaddr_ns);
144: getpeername(_serverConnection->fd, &_serverConnection->host, &namelen);
145: fprintf(stderr,"[ServerInit: argc=%d]\n",argc);
146: for (i=0; i<argc; i++) fprintf(stderr,"\targv[%d]=%s\n", i,argv[i]);
147:
148: #endif
149: skipcount = -1;
150: while (argc-- > 0) {
151: #if DEBUG
152: if (strcmp(argv[0],"-d") == 0)
153: CourierServerDebuggingFlag = 1;
154: else
155: #endif
156: if (isdigit(*argv[0])) {
157: if (skipcount < 0) {
158: _serverConnection->fd = atoi(argv[0]);
159: skipcount++;
160: }
161: else if (skipcount < 8)
162: skippedwords[skipcount++] = atoi(argv[0]);
163: }
164: argv++;
165: }
166: if (skipcount < 0 || skipcount == 1) {
167: fprintf(stderr,"in ServerInit, skipcount=%d\n",skipcount);
168: exit(1);
169: }
170: _serverConnection->state = wantversion;
171: return(skipcount);
172: }
173:
174:
175: main(argc, argv)
176: int argc;
177: char *argv[];
178: {
179: /*
180: * The caller may need to read a packet before getting to the
181: * program/version which it needs for dispatching. Data so read
182: * is passed in the argv list, and used to set skipcount and
183: * skippedwords.
184: */
185: int skipcount; /* actual length of skippedwords */
186: Unspecified skippedwords[8];
187:
188: /* ServerInit() contains server-independent startup code */
189: skipcount = ServerInit(argc, argv, skippedwords);
190:
191: /* Server() may terminate in 2 ways:
192: * (1) normally, with a return(0) and a closed connection,
193: * either from our timeout or from END sent by client.
194: * (2) abnormally, with an exit(1) indicating a protocol
195: * violation. We do not currently close down the
196: * connection in all such cases, but we should.
197: * Note that Server may also exec() a different server if
198: * a remote procedure for a different program arrives.
199: */
200: Server(skipcount, skippedwords);
201: exit(0);
202: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.