Ejemplo n.º 1
0
/**
 * This functions handles an incoming ECSS packet.
 * If the ECSS packet is part of a large data transfer consisting from
 * several sequential ECSS packets, it handles them automatically.
 *
 * In other words, there is no need to explicitly check for a fragmented data
 * transfer.
 *
 * @param payload the received payload
 * @param payload_size the size of the payload
 * @return SATR_OK if all went ok or appropriate error code
 */
SAT_returnState
rx_ecss (uint8_t *payload, const uint16_t payload_size)
{
  SAT_returnState ret;
  tc_tm_pkt *pkt;

  pkt = get_pkt (payload_size);

  if (!C_ASSERT(pkt != NULL)) {
    return SATR_ERROR;
  }
  if (unpack_pkt (payload, pkt, payload_size) == SATR_OK) {
    ret = route_pkt (pkt);
  }

  TC_TM_app_id dest = 0;

  if(pkt->type == TC) {
    dest = pkt->app_id;
  }
  else if(pkt->type == TM) {
    dest = pkt->dest_id;
  }

  if(dest == SYSTEM_APP_ID) {
      free_pkt(pkt);
  }

  return ret;
}
Ejemplo n.º 2
0
SAT_returnState hk_crt_empty_pkt_TM(tc_tm_pkt **pkt, const TC_TM_app_id app_id, const HK_struct_id sid) {

    *pkt = get_pkt(PKT_NORMAL);
    if(!C_ASSERT(*pkt != NULL) == true) { return SATR_ERROR; }

    hk_crt_pkt_TM(*pkt, app_id, sid);
    return SATR_OK;
}
Ejemplo n.º 3
0
    bool write_pkt(buf_ptr &buf_in)
    {
        buf_ptr buf_out = super::buffer();
        put_pkt(buf_in);

        do {
            get_pkt(buf_out);
            super::write_pkt(buf_out);
            buf_out->reset();
        } while (super::decrease_budget());

        return true;
    }
Ejemplo n.º 4
0
    bool read_pkt(buf_ptr &buf_out)
    {
        buf_ptr buf_in = super::buffer();

        if (!is_done() && is_partial_complete()) {
            get_pkt(buf_out);
            return true;
        } else if (is_done()) {
            increment();
            return false;
        }

        while (true) {
            super::rlnc_hdr_reserve(buf_in);

            if (!super::read_pkt(buf_in))
                break;

            if (!validate_type(buf_in))
                continue;

            put_pkt(buf_in);
            process_rank();
            buf_in->reset();

            if (is_complete()) {
                send_ack(super::rlnc_hdr_block(), base::m_coder->rank());
                break;
            }
        }

        if (!is_partial_complete())
            return false;

        get_pkt(buf_out);

        return true;
    }
Ejemplo n.º 5
0
    void timer()
    {
        buf_ptr buf;
        super::timer();

        if (base::m_coder->symbols_initialized() == 0)
            return;

        if (m_decoder_rank == base::m_coder->rank())
            return;

        if (m_stopped)
            return;

        super::increase_budget();
        buf = super::buffer();

        do {
            get_pkt(buf);
            super::write_pkt(buf);
            buf->reset();
        } while (super::decrease_budget());
    }
Ejemplo n.º 6
0
void tcp_send_recv(int server_socket) {
    int max_sock;
    fd_set all_sockets;
    fd_set read_sockets;


    printf("$: ");
    fflush(stdout);
    FD_ZERO(&all_sockets);
    FD_ZERO(&read_sockets);
    FD_SET(server_socket, &all_sockets);
    FD_SET(0, &all_sockets);
    max_sock = server_socket;


    while(1) {
        read_sockets = all_sockets;
        if (select(server_socket + 1, &read_sockets, NULL, NULL, NULL) < 0) {
            perror("select");
            exit(1);
        }

        if (FD_ISSET(server_socket, &read_sockets)) {
            if (get_pkt(server_socket) != 0) {
                FD_CLR(server_socket, &all_sockets);
                exit(0);
            }
            else {
                printf("$: ");
                fflush(stdout);
            }
        }
        if (FD_ISSET(0, &read_sockets)) {
            tcp_send_message(server_socket);
        }
    }
}
Ejemplo n.º 7
0
int server::join_game(out_socket *os, char *name, char *server_name)
{
  char *re="Error occurred while reading from server\n";
  packet pk;

  if (!get_pkt(os,pk))                  // read join status packet, 0 means we can't join
  { fputs(re,stderr); exit(0); }
  int32_t nfs_port;
  if (pk.read((uint8_t *)&nfs_port,4)!=4)
  { fputs(re,stderr); exit(0); }

//  connect_to_nfs_server(server_name,lltl(nfs_port));




  pk.write((uint8_t *)name,strlen(name)+1);  // send or name and see if it's ok to join in
  if (!send_pkt(os,pk))
  {
    printf("Unable to write to server\n");
    exit(0);
  }

  if (!get_pkt(os,pk))                  // read join status packet, 0 means we can't join
  { fputs(re,stderr); exit(0); }

  uint8_t stat;
  if (pk.read((uint8_t *)&stat,1)!=1)
  { fputs(re,stderr); exit(0); }

  if (stat==0)
  {
    printf("Sorry, this server is refusing you (%s)\n",name);
    exit(0);
  }


  if (current_level)
    delete current_level;

  int32_t vs[4]={ lltl(320/2-155),lltl(200/2-95),lltl(320/2+155),lltl(200/2+70)};
  pk.write((uint8_t *)vs,4*4);
  if (!send_pkt(os,pk))   { printf("Unable to write to server\n"); exit(0);  }


  current_level=new level(os);
  if (current_level->load_failed())
  {
    printf("Error occurred while downloading level\n");
    exit(1);
  }

  if (!get_pkt(os,pk))
  {
    printf("Unable to read views from server\n");
    exit(0);
  }
  uint16_t tv;
  if (pk.read((uint8_t *)&tv,2)!=2)
  { fputs(re,stderr); exit(0); }
  tv=lstl(tv);
  view *last=NULL;
  for (int i=0; i<tv; i++)
  {
    if (!get_pkt(os,pk)) { fputs(re,stderr); exit(0); }

    view *v=add_view(pk);
    if (v)
    {
      printf("added view %d\n",v->player_number);
      if (last)
        last->next=v;
      else player_list=v;
      last=v;
    } else printf("no view created, why?\n");

  }

  if (!get_pkt(os,pk)) { fputs(re,stderr); exit(0); }
  if (pk.read((uint8_t *)&rand_on,2)!=2)    // read the current random seed used by the server.
  { fputs(re,stderr); exit(0); }
  rand_on=lstl(rand_on);
  uint16_t rtab[1024];
  if (!pk.read((uint8_t *)rtab,1024*2)) { fputs(re,stderr); exit(0); }  // read the rand table

  for (int j=0; j<1024*2; j++)
    if (((uint8_t *)rtab)[j]!=((uint8_t *)rtable)[j])
    { printf("rtables differ on byte %d\n",j); exit(0); }

  if (last)
  {
    last->Drawable=1;
    last->connect=os;
  }

  start_running=1;
  is_server=0;
  return 1;
}
Ejemplo n.º 8
0
void server::check_for_new_players()
{
  if (is_server && has_net)
  {
    out_socket *nd=in->check_for_connect();
    if (nd)
    {
      packet pk;
//      pk.write_uint32(file_server->get_port());
      if (!send_pkt(nd,pk))
      {
    printf("error writing to connection\n");
    return ;
      }

//      while (!file_server->service_request()) milli_wait(1000);

      if (!get_pkt(nd,pk))
      {
    printf("error reading from connection\n");
    return ;
      } else
      {

    char name[100];
    pk.get_string(name,100);
    printf("Joined by player %s\n",name);
    pk.reset();
    uint8_t ok=1;
    pk.write((uint8_t *)&ok,1);      // write ok to join
    send_pkt(nd,pk);

    /**************** Read suggested view size from client ****/
    if (!get_pkt(nd,pk))
    {
      printf("error reading view info from connection\n");
      return ;
    }
    int32_t cx1,cy1,cx2,cy2;
    if (pk.read((uint8_t *)&cx1,4)!=4) return ;  cx1=lltl(cx1);
    if (pk.read((uint8_t *)&cy1,4)!=4) return ;  cy1=lltl(cy1);
    if (pk.read((uint8_t *)&cx2,4)!=4) return ;  cx2=lltl(cx2);
    if (pk.read((uint8_t *)&cy2,4)!=4) return ;  cy2=lltl(cy2);

    /**************** Create the player  *******************/
    for (view *f=player_list; f && f->next; f=f->next);      // find last player, add one for pn
    int i,st=0;
    for (i=0; i<total_objects; i++)
      if (!strcmp(object_names[i],"START"))
        st=i;

    game_object *o=create(current_start_type,0,0);
    game_object *start=current_level->get_random_start(320,NULL);
    if (start) { o->x=start->x; o->y=start->y; }
    else { o->x=100; o->y=100; }

    f->next=new view(o,NULL,f->player_number+1);
    o->set_controller(f->next);

    current_level->add_object(o);
    view *v=f->next;
    v->cx1=cx1;
    v->cy1=cy1;
    v->cx2=cx2;
    v->cy2=cy2;
    v->connect=nd;
    strcpy(v->name,name);


    if (current_level->send(nd))
    {
      uint8_t cmd=SCMD_ADD_VIEW;
      next_out.write((uint8_t *)&cmd,1);
      v->write_packet(next_out);


      /********** Send all of the views to the player **********/
      pk.reset();
      uint16_t tv=0;
      for (f=player_list; f; f=f->next) tv++;
      tv=lstl(tv);
      pk.write((uint8_t *)&tv,2);
      if (!send_pkt(nd,pk)) return ;

      for (f=player_list; f; f=f->next)
      {
        pk.reset();
        f->write_packet(pk);
        if (!send_pkt(nd,pk)) return ;
      }

      pk.reset();
      uint16_t r=lstl(rand_on);
      pk.write((uint8_t *)&r,2);       // write current random seed
      pk.write((uint8_t *)rtable,1024*2);
      send_pkt(nd,pk);

    }
      }
    }
  }
}
Ejemplo n.º 9
0
void server::collect_inputs()
{
  out_socket *collect_server=NULL;
  for (view *f=player_list; f; )
  {
    view *next=f->next;
    if (is_server)
    {
      if (f->connect)
      {
    packet pk;
    if (get_pkt(f->connect,pk))
    {
      while (!pk.eop())
      {
        uint8_t cmd;
        if (pk.read((uint8_t *)&cmd,1)==1)
          if (!process_command(f,cmd,pk))
          { remove_player(f); f=NULL; }
      }
    } else
    {
      remove_player(f);
      f=NULL;
    }

      } else
      {
        f->get_input();
    add_change_log(f,next_out,1);
      }
    }
    else
    {
      if (f->local_player())
      {
        f->get_input();
    if (f->connect && !send_inputs(f))
          remove_from_server(f);
    else if (f->connect)
          collect_server=f->connect;  // take note that we should collect the input back from the server
      }
    }
    f=next;
  }

  if (collect_server)
  {
    packet pk;
    if (!get_pkt(collect_server,pk))
    {
      for (view *f=player_list; f; f=f->next)
        if (f->local_player())
      remove_from_server(f);
    }

    if (!client_do_packet(pk))
      printf("Error occurred while processing packet from server\n");
  }

  if (is_server && in)
    distribute_changes();

}
Ejemplo n.º 10
0
int tcp_send_setup(char *host_name, char *port)
{
    int socket_num;
    struct sockaddr_in remote;       // socket address for remote side
    struct hostent *hp;              // address of remote host
    char *pktTail;
    char *fullPkt;
    int fullPktLen;
    int sent = 0;

    // create the socket
    if ((socket_num = socket(AF_INET, SOCK_STREAM, 0)) < 0)
	{
	    perror("socket call");
	    exit(-1);
	}
    

    // designate the addressing family
    remote.sin_family= AF_INET;

    // get the address of the remote host and store
    if ((hp = gethostbyname(host_name)) == NULL)
	{
        printf("Error getting hostname: %s\n", host_name);
        exit(-1);
	}
    
    memcpy((char*)&remote.sin_addr, (char*)hp->h_addr, hp->h_length);

    // get the port used on the remote side and store
    remote.sin_port= htons(atoi(port));

    if(connect(socket_num, (struct sockaddr*)&remote, sizeof(struct sockaddr_in)) < 0)
    {
        perror("connect call");
        exit(-1);
    }

    //printf("len of handle %d\n", (int)strlen(handle));
    fullPktLen = strlen(handle) + 1;
    pktTail = malloc(fullPktLen);
    pktTail[0] = (uint8_t)(fullPktLen - 1);
    memcpy(pktTail + 1, handle, strlen(handle));   
    fullPkt = create_full_packet((int8_t)1, pktTail, fullPktLen);
    fullPktLen = fullPktLen + NRML_HDR_LEN;
    free(pktTail);

    sent =  send(socket_num, fullPkt, fullPktLen, 0);
    if(sent < 0)
    {
        perror("send call");
        exit(-1);
    }

    free(fullPkt);

    // wait for ack
    get_pkt(socket_num);

    return socket_num;
}
int rdt_connect(struct in_addr dst, int scid, int dcid)
{
        int n, fd;
        pid_t pid;
        struct sockaddr_un un;
        struct in_addr src;
        struct conn_info conn_info;

        if (signal(SIGINT, sig_hand) == SIG_ERR ||
            signal(SIGHUP, sig_hand) == SIG_ERR ||
            signal(SIGQUIT, sig_hand) == SIG_ERR)
        {
                err_sys("signal() error");
        }

        src = get_addr(dst);
        pid = getpid();

        /* allocate share area for send
         * and recv process.
         */
        conn_alloc(); 
        conn_info.cact = ACTIVE;
        conn_info.pid = pid;
        conn_info.src = conn_user->src = src;
        conn_info.dst = conn_user->dst = dst;
        conn_info.scid = conn_user->scid = scid;
        conn_info.dcid = conn_user->dcid = dcid;
        conn_user->sndfd = make_fifo(pid, "snd");
        conn_user->rcvfd = make_fifo(pid, "rcv");
        conn_user->sfd = make_sock();
	conn_user->seq = conn_user->ack = 0;

        if (!mtu) {
                if (dev[0] == 0 && !get_dev(src, dev))
                        err_quit("can't get dev name");
                mtu = get_mtu(dev);
        }
        n = min(mtu, 1500);
        conn_user->mss = n;
        if ((conn_user->sndpkt = malloc(n)) == NULL)
                err_sys("malloc() sndpkt error");
        if ((conn_user->rcvpkt = malloc(n)) == NULL)
                err_sys("malloc() rcvpkt error");

        if ((fd = ux_cli(RDT_UX_SOCK, &un)) < 0)
                err_sys("ux_cli() error");
        n = sizeof(struct conn_info);
        if (sendto(fd, &conn_info, n, 0, (struct sockaddr *)&un,
                                sizeof(struct sockaddr_un)) != n)
        {
                err_sys("sendto() error");
        }
	get_pkt(conn_user->sndfd, &conn_info, NULL, 0);
	conn_user->scid = conn_info.scid;

        if (rexmt_pkt(conn_user, RDT_REQ, NULL, 0) < 0)
                err_sys("rexmt_pkt() error");

        fprintf(stderr, "rdt_connect() succeed\n");
        pkt_debug((struct rdthdr *)conn_user->sndpkt);
        
        return(0);

}