]>
Commit | Line | Data |
---|---|---|
0d0723e8 | 1 | /* |
624265c6 | 2 | * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved. |
0d0723e8 RL |
3 | * Copyright 2016 VMS Software, Inc. All Rights Reserved. |
4 | * | |
dffa7520 | 5 | * Licensed under the Apache License 2.0 (the "License"). You may not use |
0d0723e8 RL |
6 | * this file except in compliance with the License. You can obtain a copy |
7 | * in the file LICENSE in the source distribution or at | |
8 | * https://www.openssl.org/source/license.html | |
9 | */ | |
10 | ||
c7bdb6a3 RL |
11 | #ifdef __VMS |
12 | # define OPENSSL_SYS_VMS | |
13 | # pragma message disable DOLLARID | |
0d3b6583 RL |
14 | |
15 | ||
c7bdb6a3 | 16 | # include <openssl/opensslconf.h> |
0d3b6583 | 17 | |
c7bdb6a3 | 18 | # if !defined(_POSIX_C_SOURCE) && defined(OPENSSL_SYS_VMS) |
0d3b6583 RL |
19 | /* |
20 | * On VMS, you need to define this to get the declaration of fileno(). The | |
21 | * value 2 is to make sure no function defined in POSIX-2 is left undefined. | |
22 | */ | |
c7bdb6a3 RL |
23 | # define _POSIX_C_SOURCE 2 |
24 | # endif | |
25 | ||
26 | # include <stdio.h> | |
27 | ||
28 | # undef _POSIX_C_SOURCE | |
29 | ||
30 | # include <sys/types.h> | |
31 | # include <sys/socket.h> | |
32 | # include <netinet/in.h> | |
33 | # include <inet.h> | |
34 | # include <unistd.h> | |
35 | # include <string.h> | |
36 | # include <errno.h> | |
37 | # include <starlet.h> | |
38 | # include <iodef.h> | |
39 | # ifdef __alpha | |
40 | # include <iosbdef.h> | |
41 | # else | |
42 | typedef struct _iosb { /* Copied from IOSBDEF.H for Alpha */ | |
43 | # pragma __nomember_alignment | |
0d3b6583 RL |
44 | __union { |
45 | __struct { | |
46 | unsigned short int iosb$w_status; /* Final I/O status */ | |
47 | __union { | |
48 | __struct { /* 16-bit byte count variant */ | |
49 | unsigned short int iosb$w_bcnt; /* 16-bit byte count */ | |
50 | __union { | |
51 | unsigned int iosb$l_dev_depend; /* 32-bit device dependent info */ | |
52 | unsigned int iosb$l_pid; /* 32-bit pid */ | |
c7bdb6a3 RL |
53 | } iosb$r_l; |
54 | } iosb$r_bcnt_16; | |
0d3b6583 RL |
55 | __struct { /* 32-bit byte count variant */ |
56 | unsigned int iosb$l_bcnt; /* 32-bit byte count (unaligned) */ | |
57 | unsigned short int iosb$w_dev_depend_high; /* 16-bit device dependent info */ | |
c7bdb6a3 RL |
58 | } iosb$r_bcnt_32; |
59 | } iosb$r_devdepend; | |
60 | } iosb$r_io_64; | |
0d3b6583 RL |
61 | __struct { |
62 | __union { | |
63 | unsigned int iosb$l_getxxi_status; /* Final GETxxI status */ | |
64 | unsigned int iosb$l_reg_status; /* Final $Registry status */ | |
c7bdb6a3 | 65 | } iosb$r_l_status; |
0d3b6583 | 66 | unsigned int iosb$l_reserved; /* Reserved field */ |
c7bdb6a3 RL |
67 | } iosb$r_get_64; |
68 | } iosb$r_io_get; | |
69 | } IOSB; | |
70 | ||
71 | # if !defined(__VAXC) | |
72 | # define iosb$w_status iosb$r_io_get.iosb$r_io_64.iosb$w_status | |
73 | # define iosb$w_bcnt iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_16.iosb$w_bcnt | |
74 | # define iosb$r_l iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_16.iosb$r_l | |
75 | # define iosb$l_dev_depend iosb$r_l.iosb$l_dev_depend | |
76 | # define iosb$l_pid iosb$r_l.iosb$l_pid | |
77 | # define iosb$l_bcnt iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_32.iosb$l_bcnt | |
78 | # define iosb$w_dev_depend_high iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_32.iosb$w_dev_depend_high | |
79 | # define iosb$l_getxxi_status iosb$r_io_get.iosb$r_get_64.iosb$r_l_status.iosb$l_getxxi_status | |
80 | # define iosb$l_reg_status iosb$r_io_get.iosb$r_get_64.iosb$r_l_status.iosb$l_reg_status | |
81 | # endif /* #if !defined(__VAXC) */ | |
82 | ||
83 | # endif /* End of IOSBDEF */ | |
84 | ||
85 | # include <efndef.h> | |
86 | # include <stdlib.h> | |
87 | # include <ssdef.h> | |
88 | # include <time.h> | |
89 | # include <stdarg.h> | |
90 | # include <descrip.h> | |
91 | ||
92 | # include "vms_term_sock.h" | |
93 | ||
94 | # ifdef __alpha | |
0d3b6583 | 95 | static struct _iosb TerminalDeviceIosb; |
c7bdb6a3 | 96 | # else |
0d3b6583 | 97 | IOSB TerminalDeviceIosb; |
c7bdb6a3 | 98 | # endif |
0d3b6583 RL |
99 | |
100 | static char TerminalDeviceBuff[255 + 2]; | |
101 | static int TerminalSocketPair[2] = {0, 0}; | |
102 | static unsigned short TerminalDeviceChan = 0; | |
103 | ||
104 | static int CreateSocketPair (int, int, int, int *); | |
105 | static void SocketPairTimeoutAst (int); | |
106 | static int TerminalDeviceAst (int); | |
107 | static void LogMessage (char *, ...); | |
108 | ||
109 | /* | |
110 | ** Socket Pair Timeout Value (must be 0-59 seconds) | |
111 | */ | |
c7bdb6a3 | 112 | # define SOCKET_PAIR_TIMEOUT_VALUE 20 |
0d3b6583 RL |
113 | |
114 | /* | |
115 | ** Socket Pair Timeout Block which is passed to timeout AST | |
116 | */ | |
117 | typedef struct _SocketPairTimeoutBlock { | |
118 | unsigned short SockChan1; | |
119 | unsigned short SockChan2; | |
c7bdb6a3 | 120 | } SPTB; |
0d3b6583 | 121 | |
c7bdb6a3 | 122 | # ifdef TERM_SOCK_TEST |
1287dabd | 123 | |
0d3b6583 RL |
124 | /*----------------------------------------------------------------------------*/ |
125 | /* */ | |
126 | /*----------------------------------------------------------------------------*/ | |
127 | int main (int argc, char *argv[], char *envp[]) | |
128 | { | |
c7bdb6a3 RL |
129 | char TermBuff[80]; |
130 | int TermSock, | |
131 | status, | |
132 | len; | |
133 | ||
134 | LogMessage ("Enter 'q' or 'Q' to quit ..."); | |
135 | while (strcasecmp (TermBuff, "Q")) { | |
136 | /* | |
137 | ** Create the terminal socket | |
138 | */ | |
139 | status = TerminalSocket (TERM_SOCK_CREATE, &TermSock); | |
140 | if (status != TERM_SOCK_SUCCESS) | |
141 | exit (1); | |
142 | ||
143 | /* | |
144 | ** Process the terminal input | |
145 | */ | |
146 | LogMessage ("Waiting on terminal I/O ...\n"); | |
cbe29648 | 147 | len = recv (TermSock, TermBuff, sizeof(TermBuff), 0) ; |
c7bdb6a3 RL |
148 | TermBuff[len] = '\0'; |
149 | LogMessage ("Received terminal I/O [%s]", TermBuff); | |
150 | ||
151 | /* | |
152 | ** Delete the terminal socket | |
153 | */ | |
154 | status = TerminalSocket (TERM_SOCK_DELETE, &TermSock); | |
155 | if (status != TERM_SOCK_SUCCESS) | |
156 | exit (1); | |
0d3b6583 RL |
157 | } |
158 | ||
c7bdb6a3 | 159 | return 1; |
0d3b6583 RL |
160 | |
161 | } | |
c7bdb6a3 | 162 | # endif |
1287dabd | 163 | |
0d3b6583 RL |
164 | /*----------------------------------------------------------------------------*/ |
165 | /* */ | |
166 | /*----------------------------------------------------------------------------*/ | |
167 | int TerminalSocket (int FunctionCode, int *ReturnSocket) | |
168 | { | |
c7bdb6a3 RL |
169 | int status; |
170 | $DESCRIPTOR (TerminalDeviceDesc, "SYS$COMMAND"); | |
0d3b6583 | 171 | |
c7bdb6a3 RL |
172 | /* |
173 | ** Process the requested function code | |
174 | */ | |
175 | switch (FunctionCode) { | |
176 | case TERM_SOCK_CREATE: | |
177 | /* | |
178 | ** Create a socket pair | |
179 | */ | |
180 | status = CreateSocketPair (AF_INET, SOCK_STREAM, 0, TerminalSocketPair); | |
181 | if (status == -1) { | |
182 | LogMessage ("TerminalSocket: CreateSocketPair () - %08X", status); | |
183 | if (TerminalSocketPair[0]) | |
184 | close (TerminalSocketPair[0]); | |
185 | if (TerminalSocketPair[1]) | |
186 | close (TerminalSocketPair[1]); | |
26a7d938 | 187 | return TERM_SOCK_FAILURE; |
c7bdb6a3 RL |
188 | } |
189 | ||
190 | /* | |
191 | ** Assign a channel to the terminal device | |
192 | */ | |
193 | status = sys$assign (&TerminalDeviceDesc, | |
194 | &TerminalDeviceChan, | |
195 | 0, 0, 0); | |
196 | if (! (status & 1)) { | |
197 | LogMessage ("TerminalSocket: SYS$ASSIGN () - %08X", status); | |
198 | close (TerminalSocketPair[0]); | |
199 | close (TerminalSocketPair[1]); | |
26a7d938 | 200 | return TERM_SOCK_FAILURE; |
c7bdb6a3 RL |
201 | } |
202 | ||
203 | /* | |
204 | ** Queue an async IO to the terminal device | |
205 | */ | |
206 | status = sys$qio (EFN$C_ENF, | |
207 | TerminalDeviceChan, | |
208 | IO$_READVBLK, | |
209 | &TerminalDeviceIosb, | |
210 | TerminalDeviceAst, | |
211 | 0, | |
212 | TerminalDeviceBuff, | |
cbe29648 | 213 | sizeof(TerminalDeviceBuff) - 2, |
c7bdb6a3 RL |
214 | 0, 0, 0, 0); |
215 | if (! (status & 1)) { | |
216 | LogMessage ("TerminalSocket: SYS$QIO () - %08X", status); | |
217 | close (TerminalSocketPair[0]); | |
218 | close (TerminalSocketPair[1]); | |
26a7d938 | 219 | return TERM_SOCK_FAILURE; |
c7bdb6a3 RL |
220 | } |
221 | ||
222 | /* | |
223 | ** Return the input side of the socket pair | |
224 | */ | |
225 | *ReturnSocket = TerminalSocketPair[1]; | |
0d3b6583 RL |
226 | break; |
227 | ||
c7bdb6a3 RL |
228 | case TERM_SOCK_DELETE: |
229 | /* | |
230 | ** Cancel any pending IO on the terminal channel | |
231 | */ | |
232 | status = sys$cancel (TerminalDeviceChan); | |
233 | if (! (status & 1)) { | |
234 | LogMessage ("TerminalSocket: SYS$CANCEL () - %08X", status); | |
235 | close (TerminalSocketPair[0]); | |
236 | close (TerminalSocketPair[1]); | |
26a7d938 | 237 | return TERM_SOCK_FAILURE; |
c7bdb6a3 RL |
238 | } |
239 | ||
240 | /* | |
dd6b2706 P |
241 | ** Deassign the terminal channel |
242 | */ | |
c7bdb6a3 RL |
243 | status = sys$dassgn (TerminalDeviceChan); |
244 | if (! (status & 1)) { | |
245 | LogMessage ("TerminalSocket: SYS$DASSGN () - %08X", status); | |
246 | close (TerminalSocketPair[0]); | |
247 | close (TerminalSocketPair[1]); | |
26a7d938 | 248 | return TERM_SOCK_FAILURE; |
c7bdb6a3 | 249 | } |
0d3b6583 | 250 | |
c7bdb6a3 RL |
251 | /* |
252 | ** Close the terminal socket pair | |
253 | */ | |
254 | close (TerminalSocketPair[0]); | |
255 | close (TerminalSocketPair[1]); | |
256 | ||
257 | /* | |
dd6b2706 P |
258 | ** Return the initialized socket |
259 | */ | |
c7bdb6a3 RL |
260 | *ReturnSocket = 0; |
261 | break; | |
0d3b6583 RL |
262 | |
263 | default: | |
c7bdb6a3 | 264 | /* |
dd6b2706 P |
265 | ** Invalid function code |
266 | */ | |
c7bdb6a3 | 267 | LogMessage ("TerminalSocket: Invalid Function Code - %d", FunctionCode); |
26a7d938 | 268 | return TERM_SOCK_FAILURE; |
c7bdb6a3 RL |
269 | break; |
270 | } | |
0d3b6583 | 271 | |
c7bdb6a3 RL |
272 | /* |
273 | ** Return success | |
274 | */ | |
26a7d938 | 275 | return TERM_SOCK_SUCCESS; |
0d3b6583 RL |
276 | |
277 | } | |
1287dabd | 278 | |
0d3b6583 RL |
279 | /*----------------------------------------------------------------------------*/ |
280 | /* */ | |
281 | /*----------------------------------------------------------------------------*/ | |
c7bdb6a3 RL |
282 | static int CreateSocketPair (int SocketFamily, |
283 | int SocketType, | |
284 | int SocketProtocol, | |
285 | int *SocketPair) | |
0d3b6583 | 286 | { |
c7bdb6a3 RL |
287 | struct dsc$descriptor AscTimeDesc = {0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL}; |
288 | static const char* LocalHostAddr = {"127.0.0.1"}; | |
289 | unsigned short TcpAcceptChan = 0, | |
290 | TcpDeviceChan = 0; | |
291 | unsigned long BinTimeBuff[2]; | |
292 | struct sockaddr_in sin; | |
293 | char AscTimeBuff[32]; | |
294 | short LocalHostPort; | |
295 | int status; | |
296 | unsigned int slen; | |
297 | ||
298 | # ifdef __alpha | |
299 | struct _iosb iosb; | |
300 | # else | |
301 | IOSB iosb; | |
302 | # endif | |
303 | ||
304 | int SockDesc1 = 0, | |
305 | SockDesc2 = 0; | |
306 | SPTB sptb; | |
307 | $DESCRIPTOR (TcpDeviceDesc, "TCPIP$DEVICE"); | |
0d3b6583 | 308 | |
c7bdb6a3 RL |
309 | /* |
310 | ** Create a socket | |
311 | */ | |
312 | SockDesc1 = socket (SocketFamily, SocketType, 0); | |
313 | if (SockDesc1 < 0) { | |
314 | LogMessage ("CreateSocketPair: socket () - %d", errno); | |
26a7d938 | 315 | return -1; |
0d3b6583 RL |
316 | } |
317 | ||
c7bdb6a3 RL |
318 | /* |
319 | ** Initialize the socket information | |
320 | */ | |
cbe29648 | 321 | slen = sizeof(sin); |
c7bdb6a3 RL |
322 | memset ((char *) &sin, 0, slen); |
323 | sin.sin_family = SocketFamily; | |
324 | sin.sin_addr.s_addr = inet_addr (LocalHostAddr); | |
325 | sin.sin_port = 0; | |
0d3b6583 | 326 | |
c7bdb6a3 RL |
327 | /* |
328 | ** Bind the socket to the local IP | |
329 | */ | |
330 | status = bind (SockDesc1, (struct sockaddr *) &sin, slen); | |
331 | if (status < 0) { | |
332 | LogMessage ("CreateSocketPair: bind () - %d", errno); | |
333 | close (SockDesc1); | |
26a7d938 | 334 | return -1; |
0d3b6583 RL |
335 | } |
336 | ||
c7bdb6a3 RL |
337 | /* |
338 | ** Get the socket name so we can save the port number | |
339 | */ | |
340 | status = getsockname (SockDesc1, (struct sockaddr *) &sin, &slen); | |
341 | if (status < 0) { | |
342 | LogMessage ("CreateSocketPair: getsockname () - %d", errno); | |
343 | close (SockDesc1); | |
26a7d938 | 344 | return -1; |
c7bdb6a3 RL |
345 | } else |
346 | LocalHostPort = sin.sin_port; | |
0d3b6583 | 347 | |
c7bdb6a3 RL |
348 | /* |
349 | ** Setup a listen for the socket | |
350 | */ | |
351 | listen (SockDesc1, 5); | |
0d3b6583 | 352 | |
c7bdb6a3 RL |
353 | /* |
354 | ** Get the binary (64-bit) time of the specified timeout value | |
355 | */ | |
356 | sprintf (AscTimeBuff, "0 0:0:%02d.00", SOCKET_PAIR_TIMEOUT_VALUE); | |
357 | AscTimeDesc.dsc$w_length = strlen (AscTimeBuff); | |
358 | AscTimeDesc.dsc$a_pointer = AscTimeBuff; | |
359 | status = sys$bintim (&AscTimeDesc, BinTimeBuff); | |
360 | if (! (status & 1)) { | |
361 | LogMessage ("CreateSocketPair: SYS$BINTIM () - %08X", status); | |
362 | close (SockDesc1); | |
26a7d938 | 363 | return -1; |
0d3b6583 RL |
364 | } |
365 | ||
c7bdb6a3 RL |
366 | /* |
367 | ** Assign another channel to the TCP/IP device for the accept. | |
368 | ** This is the channel that ends up being connected to. | |
369 | */ | |
370 | status = sys$assign (&TcpDeviceDesc, &TcpDeviceChan, 0, 0, 0); | |
371 | if (! (status & 1)) { | |
372 | LogMessage ("CreateSocketPair: SYS$ASSIGN () - %08X", status); | |
373 | close (SockDesc1); | |
26a7d938 | 374 | return -1; |
0d3b6583 RL |
375 | } |
376 | ||
c7bdb6a3 RL |
377 | /* |
378 | ** Get the channel of the first socket for the accept | |
379 | */ | |
380 | TcpAcceptChan = decc$get_sdc (SockDesc1); | |
0d3b6583 | 381 | |
c7bdb6a3 RL |
382 | /* |
383 | ** Perform the accept using $QIO so we can do this asynchronously | |
384 | */ | |
385 | status = sys$qio (EFN$C_ENF, | |
386 | TcpAcceptChan, | |
387 | IO$_ACCESS | IO$M_ACCEPT, | |
388 | &iosb, | |
389 | 0, 0, 0, 0, 0, | |
390 | &TcpDeviceChan, | |
391 | 0, 0); | |
392 | if (! (status & 1)) { | |
393 | LogMessage ("CreateSocketPair: SYS$QIO () - %08X", status); | |
394 | close (SockDesc1); | |
395 | sys$dassgn (TcpDeviceChan); | |
26a7d938 | 396 | return -1; |
0d3b6583 RL |
397 | } |
398 | ||
c7bdb6a3 RL |
399 | /* |
400 | ** Create the second socket to do the connect | |
401 | */ | |
402 | SockDesc2 = socket (SocketFamily, SocketType, 0); | |
403 | if (SockDesc2 < 0) { | |
404 | LogMessage ("CreateSocketPair: socket () - %d", errno); | |
405 | sys$cancel (TcpAcceptChan); | |
406 | close (SockDesc1); | |
407 | sys$dassgn (TcpDeviceChan); | |
408 | return (-1) ; | |
409 | } | |
0d3b6583 | 410 | |
c7bdb6a3 RL |
411 | /* |
412 | ** Setup the Socket Pair Timeout Block | |
413 | */ | |
414 | sptb.SockChan1 = TcpAcceptChan; | |
415 | sptb.SockChan2 = decc$get_sdc (SockDesc2); | |
0d3b6583 | 416 | |
c7bdb6a3 RL |
417 | /* |
418 | ** Before we block on the connect, set a timer that can cancel I/O on our | |
419 | ** two sockets if it never connects. | |
420 | */ | |
421 | status = sys$setimr (EFN$C_ENF, | |
422 | BinTimeBuff, | |
423 | SocketPairTimeoutAst, | |
424 | &sptb, | |
425 | 0); | |
426 | if (! (status & 1)) { | |
427 | LogMessage ("CreateSocketPair: SYS$SETIMR () - %08X", status); | |
428 | sys$cancel (TcpAcceptChan); | |
429 | close (SockDesc1); | |
430 | close (SockDesc2); | |
431 | sys$dassgn (TcpDeviceChan); | |
26a7d938 | 432 | return -1; |
0d3b6583 RL |
433 | } |
434 | ||
c7bdb6a3 RL |
435 | /* |
436 | ** Now issue the connect | |
437 | */ | |
cbe29648 | 438 | memset ((char *) &sin, 0, sizeof(sin)) ; |
c7bdb6a3 RL |
439 | sin.sin_family = SocketFamily; |
440 | sin.sin_addr.s_addr = inet_addr (LocalHostAddr) ; | |
441 | sin.sin_port = LocalHostPort ; | |
442 | ||
cbe29648 | 443 | status = connect (SockDesc2, (struct sockaddr *) &sin, sizeof(sin)); |
1287dabd | 444 | if (status < 0) { |
c7bdb6a3 RL |
445 | LogMessage ("CreateSocketPair: connect () - %d", errno); |
446 | sys$cantim (&sptb, 0); | |
447 | sys$cancel (TcpAcceptChan); | |
448 | close (SockDesc1); | |
449 | close (SockDesc2); | |
450 | sys$dassgn (TcpDeviceChan); | |
26a7d938 | 451 | return -1; |
0d3b6583 RL |
452 | } |
453 | ||
c7bdb6a3 RL |
454 | /* |
455 | ** Wait for the asynch $QIO to finish. Note that if the I/O was aborted | |
456 | ** (SS$_ABORT), then we probably canceled it from the AST routine - so log | |
457 | ** a timeout. | |
458 | */ | |
459 | status = sys$synch (EFN$C_ENF, &iosb); | |
460 | if (! (iosb.iosb$w_status & 1)) { | |
461 | if (iosb.iosb$w_status == SS$_ABORT) | |
462 | LogMessage ("CreateSocketPair: SYS$QIO(iosb) timeout"); | |
463 | else { | |
464 | LogMessage ("CreateSocketPair: SYS$QIO(iosb) - %d", | |
465 | iosb.iosb$w_status); | |
466 | sys$cantim (&sptb, 0); | |
0d3b6583 | 467 | } |
c7bdb6a3 RL |
468 | close (SockDesc1); |
469 | close (SockDesc2); | |
470 | sys$dassgn (TcpDeviceChan); | |
26a7d938 | 471 | return -1; |
0d3b6583 RL |
472 | } |
473 | ||
c7bdb6a3 RL |
474 | /* |
475 | ** Here we're successfully connected, so cancel the timer, convert the | |
476 | ** I/O channel to a socket fd, close the listener socket and return the | |
477 | ** connected pair. | |
478 | */ | |
479 | sys$cantim (&sptb, 0); | |
0d3b6583 | 480 | |
c7bdb6a3 RL |
481 | close (SockDesc1) ; |
482 | SocketPair[0] = SockDesc2 ; | |
483 | SocketPair[1] = socket_fd (TcpDeviceChan); | |
0d3b6583 | 484 | |
c7bdb6a3 | 485 | return (0) ; |
0d3b6583 RL |
486 | |
487 | } | |
1287dabd | 488 | |
0d3b6583 RL |
489 | /*----------------------------------------------------------------------------*/ |
490 | /* */ | |
491 | /*----------------------------------------------------------------------------*/ | |
492 | static void SocketPairTimeoutAst (int astparm) | |
493 | { | |
c7bdb6a3 | 494 | SPTB *sptb = (SPTB *) astparm; |
0d3b6583 | 495 | |
c7bdb6a3 RL |
496 | sys$cancel (sptb->SockChan2); /* Cancel the connect() */ |
497 | sys$cancel (sptb->SockChan1); /* Cancel the accept() */ | |
0d3b6583 | 498 | |
c7bdb6a3 | 499 | return; |
0d3b6583 RL |
500 | |
501 | } | |
1287dabd | 502 | |
0d3b6583 RL |
503 | /*----------------------------------------------------------------------------*/ |
504 | /* */ | |
505 | /*----------------------------------------------------------------------------*/ | |
506 | static int TerminalDeviceAst (int astparm) | |
507 | { | |
c7bdb6a3 | 508 | int status; |
0d3b6583 | 509 | |
c7bdb6a3 RL |
510 | /* |
511 | ** Terminate the terminal buffer | |
512 | */ | |
513 | TerminalDeviceBuff[TerminalDeviceIosb.iosb$w_bcnt] = '\0'; | |
514 | strcat (TerminalDeviceBuff, "\n"); | |
0d3b6583 | 515 | |
c7bdb6a3 | 516 | /* |
46f4e1be | 517 | ** Send the data read from the terminal device through the socket pair |
c7bdb6a3 RL |
518 | */ |
519 | send (TerminalSocketPair[0], TerminalDeviceBuff, | |
520 | TerminalDeviceIosb.iosb$w_bcnt + 1, 0); | |
0d3b6583 | 521 | |
c7bdb6a3 RL |
522 | /* |
523 | ** Queue another async IO to the terminal device | |
524 | */ | |
525 | status = sys$qio (EFN$C_ENF, | |
526 | TerminalDeviceChan, | |
527 | IO$_READVBLK, | |
528 | &TerminalDeviceIosb, | |
529 | TerminalDeviceAst, | |
530 | 0, | |
531 | TerminalDeviceBuff, | |
cbe29648 | 532 | sizeof(TerminalDeviceBuff) - 1, |
c7bdb6a3 | 533 | 0, 0, 0, 0); |
0d3b6583 | 534 | |
c7bdb6a3 RL |
535 | /* |
536 | ** Return status | |
537 | */ | |
538 | return status; | |
0d3b6583 RL |
539 | |
540 | } | |
1287dabd | 541 | |
0d3b6583 RL |
542 | /*----------------------------------------------------------------------------*/ |
543 | /* */ | |
544 | /*----------------------------------------------------------------------------*/ | |
545 | static void LogMessage (char *msg, ...) | |
546 | { | |
c7bdb6a3 RL |
547 | char *Month[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", |
548 | "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; | |
549 | static unsigned int pid = 0; | |
550 | va_list args; | |
551 | time_t CurTime; | |
552 | struct tm *LocTime; | |
553 | char MsgBuff[256]; | |
0d3b6583 | 554 | |
c7bdb6a3 RL |
555 | /* |
556 | ** Get the process pid | |
557 | */ | |
558 | if (pid == 0) | |
559 | pid = getpid (); | |
0d3b6583 | 560 | |
c7bdb6a3 RL |
561 | /* |
562 | ** Convert the current time into local time | |
563 | */ | |
564 | CurTime = time (NULL); | |
565 | LocTime = localtime (&CurTime); | |
0d3b6583 | 566 | |
c7bdb6a3 RL |
567 | /* |
568 | ** Format the message buffer | |
569 | */ | |
570 | sprintf (MsgBuff, "%02d-%s-%04d %02d:%02d:%02d [%08X] %s\n", | |
571 | LocTime->tm_mday, Month[LocTime->tm_mon], | |
572 | (LocTime->tm_year + 1900), LocTime->tm_hour, LocTime->tm_min, | |
573 | LocTime->tm_sec, pid, msg); | |
0d3b6583 | 574 | |
c7bdb6a3 RL |
575 | /* |
576 | ** Get any variable arguments and add them to the print of the message | |
577 | ** buffer | |
578 | */ | |
579 | va_start (args, msg); | |
580 | vfprintf (stderr, MsgBuff, args); | |
581 | va_end (args); | |
0d3b6583 | 582 | |
c7bdb6a3 RL |
583 | /* |
584 | ** Flush standard error output | |
585 | */ | |
586 | fsync (fileno (stderr)); | |
0d3b6583 | 587 | |
c7bdb6a3 | 588 | return; |
0d3b6583 RL |
589 | |
590 | } | |
591 | #endif |