projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
import gdb-2000-01-05 snapshot
[deliverable/binutils-gdb.git] / gdb / rdi-share / etherdrv.c
1 /*
2 * Copyright (C) 1995 Advanced RISC Machines Limited. All rights reserved.
3 *
4 * This software may be freely used, copied, modified, and distributed
5 * provided that the above copyright notice is preserved in all copies of the
6 * software.
7 */
8
9 /* -*-C-*-
10 *
11 * $Revision$
12 * $Date$
13 *
14 *
15 * etherdrv.c - Ethernet Driver for Angel.
16 */
17
18 #ifdef __hpux
19 # define _POSIX_SOURCE 1
20 # define _HPUX_SOURCE 1
21 # define _XOPEN_SOURCE 1
22 #endif
23
24 #include <stdio.h>
25 #ifdef __hpux
26 # define uint hide_HPs_uint
27 #endif
28 #ifdef STDC_HEADERS
29 # include <unistd.h>
30 # ifdef __hpux
31 # undef uint
32 # endif
33 #endif
34 #include <stdlib.h>
35 #include <string.h>
36 #ifdef __hpux
37 # define uint hide_HPs_uint
38 #endif
39 #include <fcntl.h>
40 #ifdef __hpux
41 # undef uint
42 #endif
43 #include <errno.h>
44 #include <stdarg.h>
45 #include <ctype.h>
46 #include "host.h"
47
48 #ifdef COMPILING_ON_WINDOWS
49 typedef char * caddr_t;
50 # undef IGNORE
51 # include <winsock.h>
52 # include "angeldll.h"
53 #else
54 # ifdef __hpux
55 # define uint hide_HPs_uint
56 # endif
57 # include <sys/types.h>
58 # include <sys/socket.h>
59 # ifdef __hpux
60 # undef uint
61 # endif
62 # include <netdb.h>
63 # include <sys/time.h>
64 # include <sys/ioctl.h>
65 # ifdef HAVE_SYS_FILIO_H
66 # include <sys/filio.h>
67 # endif
68 # include <netinet/in.h>
69 # include <arpa/inet.h>
70 #endif
71
72 #include "hsys.h"
73 #include "devices.h"
74 #include "angel_endian.h"
75 #include "buffers.h"
76 #include "hostchan.h"
77 #include "params.h"
78 #include "logging.h"
79 #include "ethernet.h"
80
81
82 #if !defined(COMPILING_ON_WINDOWS) && !defined(STDC_HEADERS)
83 /* These two might not work for windows. */
84 extern int sys_nerr;
85 extern char * sys_errlist[];
86 #endif
87
88 #ifndef UNUSED
89 # define UNUSED(x) (x = x) /* Silence compiler warnings */
90 #endif
91
92 /*
93 * forward declarations of static functions
94 */
95 static int EthernetOpen(const char *name, const char *arg);
96 static int EthernetMatch(const char *name, const char *arg);
97 static void EthernetClose(void);
98 static int EthernetRead(DriverCall *dc, bool block);
99 static int EthernetWrite(DriverCall *dc);
100 static int EthernetIoctl(const int opcode, void *args);
101
102 /*
103 * the device descriptor for Ethernet
104 */
105 DeviceDescr angel_EthernetDevice =
106 {
107 "Ethernet",
108 EthernetOpen,
109 EthernetMatch,
110 EthernetClose,
111 EthernetRead,
112 EthernetWrite,
113 EthernetIoctl
114 };
115
116 /*
117 * descriptor for the socket that we talk down
118 */
119 static int sock = -1;
120
121 /*
122 * address of the remote target
123 */
124 static struct sockaddr_in remote, *ia = &remote;
125
126 /*
127 * array of dynamic port numbers on target
128 */
129 static unsigned short int ports[2];
130
131 /*
132 * Function: set_address
133 * Purpose: Try to get an address into an understandable form
134 *
135 * Params:
136 * Input: addr The address to parse
137 *
138 * Output: ia Structure to hold the parsed address
139 *
140 * Returns:
141 * OK: 0
142 * Error: -1
143 */
144 static int set_address(const char *const addr, struct sockaddr_in *const ia)
145 {
146 ia->sin_family = AF_INET;
147
148 /*
149 * Try address as a dotted decimal
150 */
151 ia->sin_addr.s_addr = inet_addr(addr);
152
153 /*
154 * If that failed, try it as a hostname
155 */
156 if (ia->sin_addr.s_addr == (u_int)-1)
157 {
158 struct hostent *hp = gethostbyname(addr);
159
160 if (hp == NULL)
161 return -1;
162
163 (void)memcpy((caddr_t)&ia->sin_addr, hp->h_addr, hp->h_length);
164 }
165
166 return 0;
167 }
168
169 /*
170 * Function: open_socket
171 * Purpose: Open a non-blocking UDP socket, and bind it to a port
172 * assigned by the system.
173 *
174 * Params: None
175 *
176 * Returns:
177 * OK: socket descriptor
178 * Error: -1
179 */
180 static int open_socket(void)
181 {
182 int sfd;
183 #if 0 /* see #if 0 just below -VVV- */
184 int yesplease = 1;
185 #endif
186 struct sockaddr_in local;
187
188 /*
189 * open the socket
190 */
191 #ifdef COMPILING_ON_WINDOWS
192 if ((sfd = socket(AF_INET, SOCK_DGRAM, 0)) == INVALID_SOCKET)
193 return -1;
194 #else
195 if ((sfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
196 {
197 # ifdef DEBUG
198 perror("socket");
199 # endif
200 return -1;
201 }
202 #endif
203
204 /*
205 * 960731 KWelton
206 *
207 * I don't believe that this should be necessary - if we
208 * use select(), then non-blocking I/O is redundant.
209 * Unfortunately, select() appears to be broken (under
210 * Solaris, with a limited amount of time available for
211 * debug), so this code stays in for the time being
212 */
213 #if 0
214 /*
215 * enable non-blocking I/O
216 */
217 if (ioctlsocket(sfd, FIONBIO, &yesplease) < 0)
218 {
219 # ifdef DEBUG
220 perror("ioctl(FIONBIO)");
221 # endif
222 closesocket(sfd);
223
224 return -1;
225 }
226 #endif /* 0/1 */
227
228 /*
229 * bind local address to a system-assigned port
230 */
231 memset((char *)&local, 0, sizeof(local));
232 local.sin_family = AF_INET;
233 local.sin_port = htons(0);
234 local.sin_addr.s_addr = INADDR_ANY;
235 if (bind(sfd, (struct sockaddr *)&local, sizeof(local)) < 0)
236 {
237 #ifdef DEBUG
238 perror("bind");
239 #endif
240 closesocket(sfd);
241
242 return -1;
243 }
244
245 /*
246 * all done
247 */
248 return sfd;
249 }
250
251 /*
252 * Function: fetch_ports
253 * Purpose: Request assigned port numbers from remote target
254 *
255 * Params: None
256 *
257 * Returns: Nothing
258 *
259 * Post-conditions: This routine will *always* return something for the
260 * port numbers. If the remote target does not
261 * respond, then it makes something up - this allows
262 * the standard error message (from ardi.c) to be
263 * generated when the target is dead for whatever
264 * reason.
265 */
266 static void fetch_ports(void)
267 {
268 int i;
269 char ctrlpacket[10];
270 CtrlResponse response;
271
272 memset (ctrlpacket, 0, 10);
273 strcpy (ctrlpacket, CTRL_MAGIC);
274 memset (response, 0, sizeof(CtrlResponse));
275 /*
276 * we will try 3 times to elicit a response from the target
277 */
278 for (i = 0; i < 3; ++i)
279 {
280 struct timeval tv;
281 fd_set fdset;
282
283 /*
284 * send the magic string to the control
285 * port on the remote target
286 */
287 ia->sin_port = htons(CTRL_PORT);
288 #ifdef DEBUG
289 printf("CTLR_PORT=0x%04x sin_port=0x%04x\n");
290 #endif
291
292 if (sendto(sock, ctrlpacket, sizeof(ctrlpacket), 0,
293 (struct sockaddr *)ia, sizeof(*ia)) < 0)
294 {
295 #ifdef DEBUG
296 perror("fetch_ports: sendto");
297 #endif
298 return;
299 }
300
301 FD_ZERO(&fdset);
302 FD_SET(sock, &fdset);
303 tv.tv_sec = 0;
304 tv.tv_usec = 250000;
305
306 if (select(sock + 1, &fdset, NULL, NULL, &tv) < 0)
307 {
308 #ifdef DEBUG
309 perror("fetch_ports: select");
310 #endif
311 return;
312 }
313
314 if (FD_ISSET(sock, &fdset))
315 {
316 /*
317 * there is something there - read it
318 */
319 if (recv(sock, (char *)&response, sizeof(response), 0) < 0)
320 {
321 #ifdef COMPILING_ON_WINDOWS
322 unsigned int werrno = WSAGetLastError();
323
324 if (werrno == WSAEWOULDBLOCK || werrno == 0)
325 #else
326 if (errno == EWOULDBLOCK)
327 #endif
328 {
329 --i;
330 continue;
331 }
332 else
333 {
334 #ifdef DEBUG
335 perror("fetch_ports: recv");
336 #endif
337 return;
338 }
339 }
340 {
341 /*
342 * XXX
343 *
344 * this is *very* unpleasant - try to match the structure
345 * layout
346 */
347 unsigned short *sptr = (unsigned short *)(response + RESP_DBUG);
348
349 if (strcmp(response, ctrlpacket) == 0)
350 {
351 ports[DBUG_INDEX] = htons(*sptr);
352 sptr++;
353 ports[APPL_INDEX] = htons(*sptr);
354 }
355
356 #ifdef DEBUG
357 printf("fetch_ports: got response, DBUG=%d, APPL=%d\n",
358 ports[DBUG_INDEX], ports[APPL_INDEX]);
359 #endif
360 return;
361 }
362 }
363 }
364
365 /*
366 * we failed to get a response
367 */
368 #ifdef DEBUG
369 printf("fetch_ports: failed to get a real answer\n");
370 #endif
371 }
372
373 /*
374 * Function: read_packet
375 * Purpose: read a packet, and pass it back to higher levels
376 *
377 * Params:
378 * In/Out: packet Holder for the read packet
379 *
380 * Returns: 1 - Packet is complete
381 * 0 - No complete packet read
382 *
383 * Post-conditions: Will call panic() if something goes wrong with the OS
384 */
385 static int read_packet(struct data_packet *const packet)
386 {
387 struct sockaddr_in from;
388 int nbytes, fromlen = sizeof(from);
389 DevChanID devchan;
390
391 /*
392 * try to get the packet
393 */
394 if ((nbytes = recvfrom(sock, (char *)(packet->data), packet->buf_len, 0,
395 (struct sockaddr *)&from, &fromlen)) < 0)
396 {
397 #ifdef COMPILING_ON_WINDOWS
398 if (nbytes == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
399 MessageBox(GetFocus(), "Error receiving packet\n", "Angel", MB_OK | MB_ICONSTOP);
400 #else
401 if (errno != EWOULDBLOCK)
402 {
403 # ifdef DEBUG
404 perror("recv");
405 # endif
406 panic("ethernet recv failure");
407 }
408 #endif
409 return 0;
410 }
411
412 #ifdef COMPILING_ON_WINDOWS
413 if (pfnProgressCallback != NULL && nbytes != SOCKET_ERROR)
414 {
415 progressInfo.nRead += nbytes;
416 (*pfnProgressCallback)(&progressInfo);
417 }
418 #endif
419
420 /*
421 * work out where the packet was from
422 */
423 if (from.sin_addr.s_addr != remote.sin_addr.s_addr)
424 {
425 /*
426 * not from our target - ignore it
427 */
428 #ifdef DEBUG
429 printf("read_packet: ignoring packet from %s\n",
430 inet_ntoa(from.sin_addr));
431 #endif
432
433 return 0;
434 }
435 else if (ntohs(from.sin_port) == ports[DBUG_INDEX])
436 devchan = DC_DBUG;
437 else if (ntohs(from.sin_port) == ports[APPL_INDEX])
438 devchan = DC_APPL;
439 else
440 {
441 /*
442 * unknown port number - ignore it
443 */
444 #ifdef DEBUG
445 printf("read_packet: ignore packet from port %hd\n",
446 htons(from.sin_port));
447 #endif
448
449 return 0;
450 }
451
452 #if defined(DEBUG) && !defined(DO_TRACE)
453 printf("EthernetRead: %d bytes from %s channel\n",
454 nbytes, (devchan == DC_DBUG) ? "DBUG" : "APPL");
455 #endif
456
457 #ifdef DO_TRACE
458 printf("[%d on %d]\n", nbytes, devchan);
459 {
460 int i = 0;
461 unsigned char *cptr = packet->data;
462
463 while (i < nbytes)
464 {
465 printf("<%02X ", *(cptr++));
466
467 if (!(++i % 16))
468 printf("\n");
469 }
470
471 if (i % 16)
472 printf("\n");
473 }
474 #endif
475
476 /*
477 * OK - fill in the details
478 */
479 packet->type = devchan;
480 packet->len = nbytes;
481 return 1;
482 }
483
484 /**********************************************************************/
485
486 /*
487 * Function: Ethernet_Open
488 * Purpose: Open the Ethernet device. See the documentation for
489 * DeviceOpen in drivers.h
490 *
491 * Post-conditions: Will have updated struct sockaddr_in remote (*ia)
492 * with the address of the remote target.
493 */
494 static int EthernetOpen(const char *name, const char *arg)
495 {
496 #ifdef COMPILING_ON_WINDOWS
497 WORD wVersionRequested;
498 WSADATA wsaData;
499 #endif
500 /*
501 * name is passed as e=<blah>, so skip 1st two characters
502 */
503 const char *etheraddr = name + 2;
504
505 #ifdef DEBUG
506 printf("EthernetOpen: name `%s'\n", name);
507 #endif
508
509 /* Check that the name is a valid one */
510 if (EthernetMatch(name, arg) != 0)
511 return -1;
512
513 #ifdef COMPILING_ON_WINDOWS
514 wVersionRequested = MAKEWORD(1, 1);
515 if (WSAStartup(wVersionRequested, &wsaData) != 0)
516 /*
517 * Couldn't find a useable winsock.dll.
518 */
519 return -1;
520
521 if ( LOBYTE( wsaData.wVersion ) != 1 || HIBYTE( wsaData.wVersion ) != 1 )
522 {
523 WSACleanup();
524
525 /*
526 * Couldn't find a winsock.dll with supported version.
527 */
528 return -1;
529 }
530 #endif
531
532 memset((char *)ia, 0, sizeof(*ia));
533 if (set_address(etheraddr, ia) < 0)
534 {
535 #ifdef COMPILING_ON_WINDOWS
536 /*
537 * SJ - I'm not sure that this is the correct way to handle this
538 * as Fail calls remote_disable and exits, while panic just exits.
539 * However at the time of writing remote_disable does nothing!
540 */
541 /* Panic("EthernetOpen: bad name `%s'\n", etheraddr); */
542 #else
543 Fail("EthernetOpen: bad name `%s'\n", etheraddr);
544 #endif
545 return -1;
546 }
547
548 if ((sock = open_socket()) < 0)
549 return -1;
550
551 /*
552 * fetch the port numbers assigned by the remote target
553 * to its Debug and Application sockets
554 */
555 fetch_ports();
556
557 return 0;
558 }
559
560 static int EthernetMatch(const char *name, const char *arg)
561 {
562 /* IGNORE arg */
563 if (0)
564 arg = arg;
565
566 if (name == NULL)
567 return -1;
568
569 if (tolower(name[0]) != 'e' || name[1] != '=')
570 return -1;
571
572 return 0;
573 }
574
575 static void EthernetClose(void)
576 {
577 if (sock >= 0)
578 {
579 closesocket(sock);
580 sock = -1;
581 }
582
583 #ifdef COMPILING_ON_WINDOWS
584 WSACleanup();
585 #endif
586 }
587
588 static int EthernetRead(DriverCall *dc, bool block)
589 {
590 fd_set fdset;
591 struct timeval tv;
592 int err;
593
594 FD_ZERO(&fdset);
595 FD_SET(sock, &fdset);
596
597 #ifdef COMPILING_ON_WINDOWS
598 UNUSED(block);
599 tv.tv_sec = tv.tv_usec = 0;
600 #else
601 tv.tv_sec = 0;
602 tv.tv_usec = (block ? 10000 : 0);
603 #endif
604
605 err = select(sock + 1, &fdset, NULL, NULL, &tv);
606
607 if (err < 0) {
608 if (errno == EINTR) {
609 return 0;
610 }
611 panic("ethernet select failure (errno=%i)",errno);
612 return 0;
613 }
614
615 if (FD_ISSET(sock, &fdset))
616 return read_packet(&dc->dc_packet);
617 else
618 return 0;
619 }
620
621 static int EthernetWrite(DriverCall *dc)
622 {
623 int nbytes;
624 struct data_packet *packet = &dc->dc_packet;
625
626 if (packet->type == DC_DBUG)
627 ia->sin_port = htons(ports[DBUG_INDEX]);
628 else if (packet->type == DC_APPL)
629 ia->sin_port = htons(ports[APPL_INDEX]);
630 else
631 {
632 panic("EthernetWrite: unknown devchan");
633 return 0;
634 }
635
636 #if defined(DEBUG) && !defined(DO_TRACE)
637 printf("EthernetWrite: %d bytes to %s channel\n",
638 packet->len, (packet->type == DC_DBUG) ? "DBUG" : "APPL");
639 #endif
640
641 #ifdef DO_TRACE
642 printf("[%d on %d]\n", packet->len, packet->type);
643 {
644 int i = 0;
645 unsigned char *cptr = packet->data;
646
647 while (i < packet->len)
648 {
649 printf(">%02X ", *(cptr++));
650
651 if (!(++i % 16))
652 printf("\n");
653 }
654
655 if (i % 16)
656 printf("\n");
657 }
658 #endif
659
660 if ((nbytes = sendto(sock, (char *)(packet->data), packet->len, 0,
661 (struct sockaddr *)ia, sizeof(*ia))) != packet->len)
662 {
663 #ifdef COMPILING_ON_WINDOWS
664 if (nbytes == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK)
665 #else
666 if (nbytes < 0 && errno != EWOULDBLOCK)
667 #endif
668 {
669 #ifdef DEBUG
670 perror("sendto");
671 #endif
672
673 #ifdef COMPILING_ON_WINDOWS
674 panic("ethernet send failure\n");
675 #else
676 /* might not work for Windows */
677 panic("ethernet send failure [%s]\n",
678 #ifdef STDC_HEADERS
679 strerror(errno));
680 #else
681 errno < sys_nerr ? sys_errlist[errno] : "unknown errno");
682 #endif /* STDC_HEADERS */
683 #endif
684 }
685 #ifdef DEBUG
686 else if (nbytes >= 0)
687 fprintf(stderr, "ethernet send: asked for %d, sent %d\n", packet->len, nbytes);
688 #endif
689 return 0;
690 }
691
692 #ifdef COMPILING_ON_WINDOWS
693 if (pfnProgressCallback != NULL && nbytes != SOCKET_ERROR)
694 {
695 progressInfo.nWritten += nbytes;
696 (*pfnProgressCallback)(&progressInfo);
697 }
698 #endif
699
700 return 1;
701 }
702
703 static int EthernetIoctl(const int opcode, void *args)
704 {
705 #ifdef DEBUG
706 printf( "EthernetIoctl: op %d arg %x\n", opcode, args );
707 #endif
708
709 /*
710 * IGNORE(opcode)
711 */
712 if (0)
713 {
714 int dummy = opcode;
715 UNUSED(dummy);
716 }
717 UNUSED(args);
718
719 switch ( opcode )
720 {
721 case DC_RESYNC:
722 {
723 #ifdef DEBUG
724 printf( "EthernetIoctl: resync\n" );
725 #endif
726 fetch_ports();
727 return 0;
728 }
729
730 default:
731 {
732 return -1;
733 }
734 }
735 }
736
737 /* EOF etherdrv.c */
GDB Binutils - Deliverables
This page took 0.064382 seconds and 4 git commands to generate.