Subversion Repositories openrisc

    ProtocolClean(0, JTAG_PROXY_OUT_OF_MEMORY);

                ;

                temp_uint32 = (temp_uint32 << 8) | (0x000000ff & *(rec_buf + off));

                                case 11:

                                        printf("0x%08x  ", temp_uint32);

                                        break;

                                case 15:

                                        printf("0x%08x\n", temp_uint32);

                                        break;

                                default:

                                        break;

/* Added by CZ 24/05/01 */

int GetServerSocket(const char* name, const char* proto, int port) {

  struct servent *service;

  struct protoent *protocol;

  struct sockaddr_in sa;

  struct hostent *hp;

  int sockfd;

  char myname[256];

  //int flags; --changed to socklen_t for c++?! -- Julius

  socklen_t flags;

  char sTemp[256];

  /* First, get the protocol number of TCP */

  if (!(protocol = getprotobyname(proto))) {

    sprintf(sTemp, "Unable to load protocol \"%s\"", proto);

    perror(sTemp);

    return 0;

  }

  tcp_level = protocol->p_proto; /* Save for later */

  /* If we weren't passed a non standard port, get the port

     from the services directory. */

  if (!port && (service = getservbyname(name, protocol->p_name)))

    port = ntohs(service->s_port);

  /* Create the socket using the TCP protocol */

  if ((sockfd = socket(PF_INET, SOCK_STREAM, protocol->p_proto)) < 0) {

    perror("Unable to create socket");

    return 0;

  }

  flags = 1;

  if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,

                 (const char*)&flags, sizeof(int)) < 0) {

    sprintf(sTemp, "Can not set SO_REUSEADDR option on socket %d", sockfd);

    perror(sTemp);

    close(sockfd);

    return 0;

  }

  /* The server should also be non blocking. Get the current flags. */

  if(fcntl(sockfd, F_GETFL, &flags) < 0) {

    sprintf(sTemp, "Unable to get flags for socket %d", sockfd);

    perror(sTemp);

    close(sockfd);

    return 0;

  }

  /* Set the nonblocking flag */

  if(fcntl(sockfd, F_SETFL, flags | O_NONBLOCK) < 0) {

    sprintf(sTemp, "Unable to set flags for socket %d to value 0x%08x",

                    sockfd, flags | O_NONBLOCK);

    perror(sTemp);

    close(sockfd);

    return 0;

  }

  /* Find out what our address is */

  memset(&sa, 0, sizeof(struct sockaddr_in));

  gethostname(myname, sizeof(myname));

  if(!(hp = gethostbyname(myname))) {

    perror("Unable to read hostname");

    close(sockfd);

    return 0;

  }

  /* Bind our socket to the appropriate address */

  sa.sin_family = hp->h_addrtype;

  sa.sin_port = htons(port);

  if(bind(sockfd, (struct sockaddr*)&sa, sizeof(struct sockaddr_in)) < 0) {

    sprintf(sTemp, "Unable to bind socket %d to port %d", sockfd, port);

    perror(sTemp);

    close(sockfd);

    return 0;

  }

  serverIP = sa.sin_addr.s_addr;

  flags = sizeof(struct sockaddr_in);

  if(getsockname(sockfd, (struct sockaddr*)&sa, &flags) < 0) {

    sprintf(sTemp, "Unable to get socket information for socket %d", sockfd);

    perror(sTemp);

    close(sockfd);

    return 0;

  }

  serverPort = ntohs(sa.sin_port);

  /* Set the backlog to 1 connections */

  if(listen(sockfd, 1) < 0) {

    sprintf(sTemp, "Unable to set backlog on socket %d to %d", sockfd, 1);

    perror(sTemp);

    close(sockfd);

    return 0;

  }

  return sockfd;

}

//void HandleServerSocket(Boolean block) {

void HandleServerSocket(void) {

  struct pollfd fds[2];

  int n;

  uint32_t              temp_uint32;

 rebuild:

  n = 0;

  if(!server_fd && !gdb_fd) return;

  if(server_fd) {

    fds[n].fd = server_fd;

    fds[n].events = POLLIN;

    fds[n++].revents = 0;

  }

  if(gdb_fd) {

    fds[n].fd = gdb_fd;

    fds[n].events = POLLIN;

    fds[n++].revents = 0;

  }

  while(1) {

    switch(poll(fds, n, -1)) {

    case 0:

    case -1:

      if(errno == EINTR) continue;

      perror("poll");

      server_fd = 0;

      return;

    default:

      /* Make sure to handle the gdb port first! */

      if (gdb_fd && ((fds[0].revents && !server_fd) || (fds[1].revents && server_fd)))

        {

          int revents = server_fd ? fds[1].revents : fds[0].revents;

          if (revents & POLLIN){

            /* If we have an unacknowledged exception tell the GDB client. If this

               exception was a trap due to a memory breakpoint, then adjust the NPC. */

            if (rsp.client_waiting)

              {

                err = gdb_read_reg(PPC_CPU_REG_ADD, &temp_uint32);

                if(err) printf("Error read from PPC register\n");

                if ((TARGET_SIGNAL_TRAP == rsp.sigval) &&

                    (NULL != mp_hash_lookup (BP_MEMORY, temp_uint32)))

                  {

                    set_npc (temp_uint32);

                  }

                rsp_report_exception();

                rsp.client_waiting = 0;          /* No longer waiting */

              }

            GDBRequest();

          }

          else {/* Error Occurred */

            printf("\n%sSocket closed.\n",printTime());

            //fprintf(stderr, 

            //"Received flags 0x%08x on gdb socket. Shutting down.\n", revents);

            close(gdb_fd);

            gdb_fd = 0;

          }

        }

      // Go to blocking accept() instead of looping around through poll(), 

      // takes a loot of CPU resources and it doesn't work when 

      // reconnecting... Jonas Rosén

      if(!gdb_fd)

      {

                          JTAGRequest();

                          rsp.client_waiting = 0;                /* No longer waiting */

                          goto rebuild;

      }

      if(fds[0].revents && server_fd) {

        if(fds[0].revents & POLLIN) {

          JTAGRequest();

          rsp.client_waiting = 0;                /* No longer waiting */

          goto rebuild;

        } else { /* Error Occurred */

                          fprintf(stderr,

                                  "Received flags 0x%08x on server. Shutting down.\n",

                                  fds[0].revents);

                          close(server_fd);

                          server_fd = 0;

                          serverPort = 0;

                          serverIP = 0;

                          return;

                                }

                }

      break;

    } /* End of switch statement */

  } /* End of while statement */

}

void JTAGRequest(void) {

  struct sockaddr_in sa;

  struct sockaddr* addr = (struct sockaddr*)&sa;

  //int n = sizeof(struct sockaddr_in); --changed to socklen_t from int type

  socklen_t n = sizeof(struct sockaddr_in);

  int fd = accept(server_fd, addr, &n);

  int on_off = 0; /* Turn off Nagel's algorithm on the socket */

  int flags;

  char sTemp[256];

  if (DEBUG_GDB) printf("JTAGRequest\n");

  if(fd < 0) {

    /* This is valid, because a connection could have started,

       and then terminated due to a protocol error or user

       initiation before the accept could take place. */

    if(errno != EWOULDBLOCK && errno != EAGAIN) {

      perror("accept");

      close(server_fd);

      server_fd = 0;

      serverPort = 0;

      serverIP = 0;

    }

    return;

  }

  if(gdb_fd) {

    close(fd);

    return;

  }

  if(fcntl(fd, F_GETFL, &flags) < 0) {

    sprintf(sTemp, "Unable to get flags for gdb socket %d", fd);

    perror(sTemp);

    close(fd);

    return;

  }

  /* Rene

  if(fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {

    sprintf(sTemp, "Unable to set flags for gdb socket %d to value 0x%08x",

      fd, flags | O_NONBLOCK);

    perror(sTemp);

    close(fd);

    return;

  }     Rene */

  if(setsockopt(fd, tcp_level, TCP_NODELAY, &on_off, sizeof(int)) < 0) {

    sprintf(sTemp, "Unable to disable Nagel's algorithm for socket %d.\nsetsockopt", fd);

    perror(sTemp);

    close(fd);

    return;

  }

  printf("\n%sConnection established from %s on port %d\n", printTime(),inet_ntoa(sa.sin_addr),ntohs(sa.sin_port));

  gdb_fd = fd;

}

/*---------------------------------------------------------------------------

* Decode the GDB command.

*

*---------------------------------------------------------------------------*/

static void GDBRequest(void) {

  JTAGProxyWriteMessage msg_write;

  JTAGProxyReadMessage msg_read;

  JTAGProxyChainMessage msg_chain;

  JTAGProxyWriteResponse resp_write;

  JTAGProxyReadResponse resp_read;

  JTAGProxyChainResponse resp_chain;

  JTAGProxyBlockWriteMessage *msg_bwrite;

  JTAGProxyBlockReadMessage msg_bread;

  JTAGProxyBlockWriteResponse resp_bwrite;

  JTAGProxyBlockReadResponse *resp_bread;

  char *p_buf;

  uint32_t command;

  uint32_t length;

  int len, i;

  /* First, we must read the incomming command */

  if(gdb_read(&command, sizeof(uint32_t)) < 0) {

    client_close ('1');

    return;

  }

  command = ntohl(command);

  if(gdb_read(&length, sizeof(uint32_t)) < 0) {