LXR 6.1/​cpukit/​libdebugger/​rtems-debugger-remote-tcp.c	Source navigation Diff markup Identifier search General search
	Version: 6.1 Revert   Change

File indexing completed on 2025-05-11 08:24:15

 /*
  * Copyright (c) 2016 Chris Johns <chrisj@rtems.org>.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include <errno.h>
 #include <stdlib.h>
 #include <unistd.h>
 
 #include <arpa/inet.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 
 #include <rtems/rtems-debugger.h>
 #include <rtems/debugger/rtems-debugger-server.h>
 #include <rtems/debugger/rtems-debugger-remote.h>
 
 #include <rtems/rtems-debugger-remote-tcp.h>
 
 /**
  * Debugger default server port. 'RT' as ASCII.
  */
 #define RTEMS_DB_PORT_DEFAULT (8284)
 
 /**
  * TCP Remote data.
  */
 typedef struct
 {
   int fd;
   int port;
 } rtems_debugger_remote_tcp;
 
 static rtems_debugger_remote_tcp*
 tcp_remote(rtems_debugger_remote* remote)
 {
   rtems_debugger_remote_tcp* tcp = NULL;
   rtems_debugger_lock();
   if (remote != NULL && remote->data != NULL)
       tcp = (rtems_debugger_remote_tcp*) remote->data;
   rtems_debugger_unlock();
   return tcp;
 }
 
 static int
 tcp_remote_begin(rtems_debugger_remote* remote, const char* device)
 {
   rtems_debugger_remote_tcp* tcp;
   int                        port;
   char*                      end;
 
   rtems_debugger_lock();
 
   /*
    * Parse the port number.
    */
   port = strtoul(device, &end, 10);
   if (port == 0 || *end != '\0') {
     rtems_debugger_printf("error: rtems-db: tcp remote: invalid port: %s\n", device);
     return -1;
   }
 
   tcp = malloc(sizeof(rtems_debugger_remote_tcp));
   if (tcp == NULL) {
     errno = ENOMEM;
     return -1;
   }
 
   remote->data = tcp;
 
   tcp->fd = -1;
   tcp->port = port;
 
   rtems_debugger_unlock();
 
   return 0;
 }
 
 static int
 tcp_remote_end(rtems_debugger_remote* remote)
 {
   rtems_debugger_lock();
 
   if (remote != NULL && remote->data != NULL) {
     rtems_debugger_remote_tcp* tcp = (rtems_debugger_remote_tcp*) remote->data;
     if (tcp != NULL) {
       if (tcp->fd >= 0)
         close(tcp->fd);
       free(tcp);
       remote->data = NULL;
     }
   }
 
   rtems_debugger_unlock();
 
   return 0;
 }
 
 static int
 tcp_remote_connect(rtems_debugger_remote* remote)
 {
   int                        ld;
   struct sockaddr_in         addr = {0};
   socklen_t                  opt;
   socklen_t                  len;
   bool                       running;
   struct timeval             timeout;
   rtems_debugger_remote_tcp* tcp = tcp_remote(remote);
   int                        r;
 
   if (rtems_debugger_verbose())
     rtems_debugger_printf("error: rtems-db: tcp remote: connect\n");
 
   ld = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
   if (ld < 0) {
     rtems_debugger_printf("error: rtems-db: tcp remote: socket: (%d) %s\n",
                           errno, strerror(errno));
     return -1;
   }
 
   opt = 1;
   r = setsockopt(ld,
                  SOL_SOCKET,
                  SO_REUSEADDR,
                  (char *) &opt,
                  sizeof(opt));
   if (r < 0) {
     close(ld);
     rtems_debugger_printf("error: rtems-db: tcp remote: setsocket: reuseaddr: (%d) %s\n",
                           errno, strerror(errno));
     return -1;
   }
 
   addr.sin_family = PF_INET;
   addr.sin_port = htons(tcp->port);
   addr.sin_addr.s_addr = INADDR_ANY;
 
   r = bind(ld, (struct sockaddr *) &addr, sizeof(addr));
   if (r < 0) {
     close(ld);
     rtems_debugger_printf("error: rtems-db: tcp remote: bind: (%d) %s\n",
                           errno, strerror(errno));
     return -1;
   }
 
   /*
    * Backlog of 1 connection.
    */
   r = listen(ld, 1);
   if (r < 0) {
     close(ld);
     rtems_debugger_printf("error: rtems-db: tcp remote: listen: (%d) %s\n",
                           errno, strerror(errno));
     return -1;
   }
 
   /*
    * Use a random port if the port is 0.
    */
   if (tcp->port == 0) {
     len = sizeof(addr);
     r = getsockname(ld, (struct sockaddr *) &addr, &len);
     if (r < 0 || len < sizeof(addr)) {
       close(ld);
       rtems_debugger_printf("error: rtems-db: tcp remote: getsockname: (%d) %s\n",
                             errno, strerror(errno));
       return -1;
     }
     tcp->port = ntohs(addr.sin_port);
   }
 
   rtems_debugger_printf("rtems-db: tcp remote: listing on port: %d\n",
                         tcp->port);
 
   len = sizeof(addr);
   tcp->fd = accept(ld, (struct sockaddr *) &addr, &len);
 
   running = rtems_debugger_server_running();
 
   close(ld);
 
   if (tcp->fd < 0) {
     /*
      * EBADF means the socket has been closed, ignore it.
      */
     if (errno != EBADF)
       rtems_debugger_printf("error: rtems-db: accept: (%d) %s\n",
                             errno, strerror(errno));
     return -1;
   }
 
   if (!running) {
     close(tcp->fd);
     errno = EIO;
     return -1;
   }
 
   opt = 1;
   r = setsockopt(tcp->fd,
                  SOL_SOCKET, SO_KEEPALIVE,
                  (char*) &opt,
                  sizeof(opt));
   if (r < 0) {
     int errno_ = errno;
     close(tcp->fd);
     rtems_debugger_printf("error: rtems-db: tcp remote: set keepalive: (%d) %s\n",
                           errno, strerror(errno));
     errno = errno_;
     return -1;
   }
 
   opt = 1;
   r = setsockopt(tcp->fd,
                  IPPROTO_TCP, TCP_NODELAY,
                  (char*) &opt, sizeof(opt));
   if (r < 0) {
     int errno_ = errno;
     close(tcp->fd);
     rtems_debugger_printf("error: rtems-db: tcp remote: set no-delay: (%d) %s\n",
                           errno, strerror(errno));
     errno = errno_;
     return -1;
   }
 
   timeout.tv_sec = rtems_debugger->timeout;
   timeout.tv_usec = 0;
 
   r = setsockopt(tcp->fd,
                  SOL_SOCKET, SO_RCVTIMEO,
                  (char*) &timeout, sizeof(timeout));
   if (r < 0) {
     int errno_ = errno;
     close(tcp->fd);
     rtems_debugger_printf("error: rtems-db: tcp remote: set rcv-timeout: (%d) %s\n",
                           errno, strerror(errno));
     errno = errno_;
     return -1;
   }
 
   rtems_debugger_printf("rtems-db: tcp remote: connect host: %s\n",
                         inet_ntoa(addr.sin_addr));
 
   return 0;
 }
 
 static int
 tcp_remote_disconnect(rtems_debugger_remote* remote)
 {
   rtems_debugger_remote_tcp* tcp;
 
   rtems_debugger_lock();
 
   rtems_debugger_printf("rtems-db: tcp remote: disconnect host\n");
 
   tcp = (rtems_debugger_remote_tcp*) remote->data;
   close(tcp->fd);
   tcp->fd = -1;
 
   rtems_debugger_unlock();
 
   return 0;
 }
 
 static bool
 tcp_remote_isconnected(rtems_debugger_remote* remote)
 {
   rtems_debugger_remote_tcp* tcp = tcp_remote(remote);
   return tcp != NULL && tcp->fd >= 0;
 }
 
 static ssize_t
 tcp_remote_receive(rtems_debugger_remote* remote,
                    void*                  buf,
                    size_t                 nbytes)
 {
   rtems_debugger_remote_tcp* tcp = tcp_remote(remote);
   ssize_t                    len;
   if (tcp != NULL) {
     len = read(tcp->fd, buf, nbytes);
   }
   else {
     errno = EIO;
     len = -1;
   }
   return len;
 }
 
 static ssize_t
 tcp_remote_send(rtems_debugger_remote* remote,
                 const void*            buf,
                 size_t                 nbytes)
 {
   rtems_debugger_remote_tcp* tcp = tcp_remote(remote);
   ssize_t                    len;
   if (tcp != NULL) {
     len = write(tcp->fd, buf, nbytes);
   }
   else {
     errno = EIO;
     len = -1;
   }
   return len;
 }
 
 static rtems_debugger_remote remote_tcp =
 {
   .name = "tcp",
   .begin = tcp_remote_begin,
   .end = tcp_remote_end,
   .connect = tcp_remote_connect,
   .disconnect = tcp_remote_disconnect,
   .isconnected = tcp_remote_isconnected,
   .read = tcp_remote_receive,
   .write = tcp_remote_send
 };
 
 int
 rtems_debugger_register_tcp_remote(void)
 {
   return rtems_debugger_remote_register(&remote_tcp);
 }

This page was automatically generated by the 2.3.7 LXR engine. The LXR team