Пример #1
0
struct rtp_recorder_t* rtp_recorder_create(crypt_aes_p crypt, bool disable_audio, audio_queue_p audio_queue, struct sockaddr* local_end_point, struct sockaddr* remote_end_point, uint16_t remote_control_port, uint16_t remote_timing_port) {
    
    struct rtp_recorder_t* rr = (struct rtp_recorder_t*)malloc(sizeof(struct rtp_recorder_t));
    bzero(rr, sizeof(struct rtp_recorder_t));
    
    rr->crypt = crypt;
    rr->disable_audio = disable_audio;
    rr->audio_queue = audio_queue;
    
    rr->timer_mutex = mutex_create();
    rr->timer_cond = condition_create();
    
    rr->remote_control_end_point = sockaddr_copy(remote_end_point);
    rr->remote_timing_end_point = sockaddr_copy(remote_end_point);
    
    sockaddr_set_port(rr->remote_control_end_point, remote_control_port);
    sockaddr_set_port(rr->remote_timing_end_point, remote_timing_port);
    
    rr->streaming_socket = _rtp_recorder_create_socket(rr, "Straming socket", local_end_point, remote_end_point);
    rr->control_socket = _rtp_recorder_create_socket(rr, "Control socket", local_end_point, remote_end_point);
    rr->timing_socket = _rtp_recorder_create_socket(rr, "Timing socket", local_end_point, remote_end_point);
    
    return rr;
    
}
Пример #2
0
uint32_t
StunClient_startSTUNTrace(STUN_CLIENT_DATA*      clientData,
                          void*                  userCtx,
                          const struct sockaddr* serverAddr,
                          const struct sockaddr* baseAddr,
                          bool                   useRelay,
                          const char*            ufrag,
                          const char*            password,
                          uint8_t                ttl,
                          StunMsgId              transactionId,
                          uint32_t               sockhandle,
                          STUN_SENDFUNC          sendFunc,
                          STUNCB                 stunCbFunc,
                          DiscussData*           discussData)          /*NULL if
                                                                        * none*/

{
  StunBindReqStruct     m;
  STUN_TRANSACTION_DATA trans;
  StunMessage           stunMsg;
  uint8_t               stunBuff[STUN_MAX_PACKET_SIZE];
  uint32_t              len;

  memset( &m, 0, sizeof(m) );
  m.userCtx = userCtx;
  sockaddr_copy( (struct sockaddr*)&m.serverAddr, serverAddr );
  sockaddr_copy( (struct sockaddr*)&m.baseAddr,   baseAddr );
  m.useRelay = useRelay;
  strncpy(m.ufrag,    ufrag,    sizeof(m.ufrag) - 1);
  strncpy(m.password, password, sizeof(m.password) - 1);

  m.ttl           = ttl;
  m.transactionId = transactionId;
  m.sockhandle    = sockhandle;
  m.sendFunc      = sendFunc;
  m.discussData   = discussData;
  m.addSoftware   = false;
  /* callback and data (owned by caller) */
  m.stunCbFunc = stunCbFunc;
  m.stuntrace  = true;

  StoreStunBindReq(&trans, &m);
  BuildStunBindReq(&trans, &stunMsg);
  StunClientMain(clientData, STUNCLIENT_CTX_UNKNOWN, STUN_SIGNAL_BindReq,
                 (uint8_t*)&m);
  len = stunlib_encodeMessage(&stunMsg,
                              (uint8_t*)stunBuff,
                              STUN_MAX_PACKET_SIZE,
                              (unsigned char*)password,           /* md5key */
                              password ? strlen(password) : 0,    /* keyLen */
                              NULL);
  return len;
}
Пример #3
0
int32_t
StunClient_startBindTransaction(STUN_CLIENT_DATA*      clientData,
                                void*                  userCtx,
                                const struct sockaddr* serverAddr,
                                const struct sockaddr* baseAddr,
                                int                    proto,
                                bool                   useRelay,
                                const char*            ufrag,
                                const char*            password,
                                uint32_t               peerPriority,
                                bool                   useCandidate,
                                bool                   iceControlling,
                                uint64_t               tieBreaker,
                                StunMsgId              transactionId,
                                uint32_t               sockhandle,
                                STUN_SENDFUNC          sendFunc,
                                STUNCB                 stunCbFunc,
                                DiscussData*           discussData)
{
  StunBindReqStruct m;

  if (clientData == NULL)
  {
    return STUNCLIENT_CTX_UNKNOWN;
  }

  memset( &m, 0, sizeof(m) );
  m.userCtx = userCtx;
  sockaddr_copy( (struct sockaddr*)&m.serverAddr, serverAddr );
  sockaddr_copy( (struct sockaddr*)&m.baseAddr,   baseAddr );
  strncpy(m.ufrag,    ufrag,    sizeof(m.ufrag) - 1);
  strncpy(m.password, password, sizeof(m.password) - 1);
  m.proto          = proto;
  m.useRelay       = useRelay;
  m.peerPriority   = peerPriority;
  m.useCandidate   = useCandidate;
  m.iceControlling = iceControlling;
  m.tieBreaker     = tieBreaker;
  m.transactionId  = transactionId;
  m.sockhandle     = sockhandle;
  m.sendFunc       = sendFunc;

  m.discussData = discussData;
  m.addSoftware = true;

  /* callback and data (owned by caller) */
  m.stunCbFunc = stunCbFunc;
  StunClientMain(clientData, STUNCLIENT_CTX_UNKNOWN, STUN_SIGNAL_BindReq,
                 (uint8_t*)&m);

  return 0;
}
Пример #4
0
static void
ICMPRespCallback(STUN_TRANSACTION_DATA* trans,
                 const struct sockaddr* srcAddr)
{
  STUN_CLIENT_DATA*  client = trans->client;
  char               ip_str [SOCKADDR_MAX_STRLEN];
  StunCallBackData_T res;

  memset( &res, 0, sizeof (StunCallBackData_T) );

  memcpy( &res.msgId, &trans->stunBindReq.transactionId, sizeof(StunMsgId) );

  res.stunResult = StunResult_ICMPResp;
  res.ICMPtype   = trans->ICMPtype;
  res.ttl        = trans->ttl;

  res.rtt         = getRTTvalue(trans);
  res.retransmits = trans->retransmits;
  sockaddr_copy( (struct sockaddr*)&res.srcAddr,
                 srcAddr );

  StunPrint( client->logUserData, client->Log_cb, StunInfoCategory_Info,
             "<STUNCLIENT:%02d> ICMPResp from src: %s",
             trans->inst,
             sockaddr_toString( (struct sockaddr*) &res.srcAddr, ip_str,
                                SOCKADDR_MAX_STRLEN,
                                true ) );


  if (trans->stunBindReq.stunCbFunc)
  {
    (trans->stunBindReq.stunCbFunc)(trans->stunBindReq.userCtx, &res);
  }
}
Пример #5
0
static void
sendPacket(void*                  ctx,
           int                    sockfd,
           const uint8_t*         buf,
           int                    len,
           const struct sockaddr* addr,
           int                    proto,
           bool                   useRelay,
           uint8_t                ttl)
{
  (void) ctx;
  (void) sockfd;
  (void) len;
  (void) proto;
  (void) useRelay;
  char addr_str[SOCKADDR_MAX_STRLEN];
  /* find the transaction id  so we can use this in the simulated resp */
  memcpy(&LastTransId, &buf[8], STUN_MSG_ID_SIZE);
  memcpy(&LastTransId, &buf[8], STUN_MSG_ID_SIZE);

  sockaddr_copy( (struct sockaddr*)&LastAddress, addr );

  sockaddr_toString(addr, addr_str, SOCKADDR_MAX_STRLEN, true);

  LastTTL = ttl;
}
Пример #6
0
void
StunClient_HandleIncResp(STUN_CLIENT_DATA*      clientData,
                         const StunMessage*     msg,
                         const struct sockaddr* srcAddr)
{
  if (clientData == NULL)
  {
    return;
  }

  for (int i = 0; i < MAX_STUN_TRANSACTIONS; i++)
  {
    STUN_TRANSACTION_DATA* trans = &clientData->data[i];
    if ( trans->inUse &&
         TransIdIsEqual(&msg->msgHdr.id, &trans->stunBindReq.transactionId) )
    {
      StunRespStruct m;
      gettimeofday(&trans->stop[trans->retransmits], NULL);
      memcpy( &m.stunRespMessage, msg, sizeof(m.stunRespMessage) );
      sockaddr_copy( (struct sockaddr*)&m.srcAddr, srcAddr );
      StunClientMain(clientData, i, StunMsgToInternalStunSig(msg), (void*)&m);
      return;
    }
  }
  StunPrint(clientData->logUserData,
            clientData->Log_cb,
            StunInfoCategory_Trace,
            "<STUNCLIENT> no instance with transId, discarding, msgType %d\n ",
            msg->msgHdr.msgType);
}
Пример #7
0
void
StunTraceCallBack(void*                    userCtx,
                  StunTraceCallBackData_T* data)
{
  (void) userCtx;
  if (data->nodeAddr == NULL)
  {
    sockaddr_copy( (struct sockaddr*)&LastHopAddr, data->nodeAddr );
  }
  else
  {
    sockaddr_copy( (struct sockaddr*)&LastHopAddr, data->nodeAddr );
  }
  Done       = data->done;
  EndOfTrace = data->traceEnd;

}
Пример #8
0
struct sockaddr *
sockaddr_dup(const struct sockaddr *src, int flags)
{
	struct sockaddr *dst;

	if ((dst = sockaddr_alloc(src->sa_family, src->sa_len, flags)) == NULL)
		return NULL;

	return sockaddr_copy(dst, dst->sa_len, src);
}
Пример #9
0
void TurnStatusCallBack(void *ctx, TurnCallBackData_T *retData)
{
    
    struct turn_allocation *turnResult = (struct turn_allocation *)ctx;

    if ( retData->turnResult == TurnResult_AllocOk ){

        sockaddr_copy((struct sockaddr *)&turnResult->activeTurnServerAddr, 
                      (struct sockaddr *)&retData->TurnResultData.AllocResp.activeTurnServerAddr);

        
        sockaddr_copy((struct sockaddr *)&turnResult->rflxAddr, 
                      (struct sockaddr *)&retData->TurnResultData.AllocResp.srflxAddr);

        sockaddr_copy((struct sockaddr *)&turnResult->relAddrIPv4, 
                      (struct sockaddr *)&retData->TurnResultData.AllocResp.relAddrIPv4);

        sockaddr_copy((struct sockaddr *)&turnResult->relAddrIPv6, 
                      (struct sockaddr *)&retData->TurnResultData.AllocResp.relAddrIPv6);

        
    }else if (retData->turnResult == TurnResult_CreatePermissionOk) {
        
        turnResult->turnPerm.ok = true;
        
        
    }else if (retData->turnResult == TurnResult_RelayReleaseComplete){
        
                
        memset(&turnResult->activeTurnServerAddr, 0,sizeof(struct sockaddr_storage));
        //memset(&turnResult->hostAddr, 0,sizeof(struct sockaddr_storage));
        memset(&turnResult->rflxAddr, 0,sizeof(struct sockaddr_storage));
        memset(&turnResult->relAddrIPv4, 0,sizeof(struct sockaddr_storage));
        memset(&turnResult->relAddrIPv6, 0,sizeof(struct sockaddr_storage));
        memset(&turnResult->turnPerm, 0,sizeof(struct turn_permissions));
        
        
    }
    turnResult->update_turninfo();
}
Пример #10
0
static void
BindRespCallback(STUN_TRANSACTION_DATA* trans,
                 const struct sockaddr* srcAddr)
{
  STUN_CLIENT_DATA*  client = trans->client;
  char               ip_str [SOCKADDR_MAX_STRLEN];
  StunCallBackData_T res;

  memset( &res, 0, sizeof (StunCallBackData_T) );

  memcpy( &res.msgId, &trans->stunBindReq.transactionId, sizeof(StunMsgId) );

  res.stunResult = StunResult_BindOk;

  sockaddr_copy( (struct sockaddr*)&res.rflxAddr,
                 (struct sockaddr*)&trans->rflxAddr );

  sockaddr_copy( (struct sockaddr*)&res.srcAddr,
                 srcAddr );

  sockaddr_copy( (struct sockaddr*)&res.dstBaseAddr,
                 (struct sockaddr*)&trans->stunBindReq.baseAddr );

  /* So did we loose a packet, or got an answer to the first response?*/

  res.rtt = getRTTvalue(trans);
  res.ttl = trans->stunBindReq.ttl;

  StunPrint( client->logUserData, client->Log_cb, StunInfoCategory_Info,
             "<STUNCLIENT:%02d> BindResp from src: %s",
             trans->inst,
             sockaddr_toString( (struct sockaddr*) &res.srcAddr, ip_str,
                                SOCKADDR_MAX_STRLEN,
                                true ) );

  if (trans->stunBindReq.stunCbFunc)
  {
    (trans->stunBindReq.stunCbFunc)(trans->stunBindReq.userCtx, &res);
  }
}
Пример #11
0
struct sockaddr *
sockaddr_externalize(struct sockaddr *dst, socklen_t socklen,
    const struct sockaddr *src)
{
	struct domain *dom;

	dom = pffinddomain(src->sa_family);

	if (dom != NULL && dom->dom_sockaddr_externalize != NULL)
		return (*dom->dom_sockaddr_externalize)(dst, socklen, src);

	return sockaddr_copy(dst, socklen, src);
}
Пример #12
0
struct sockaddr *
sockaddr_in6_externalize(struct sockaddr *dst, socklen_t socklen,
    const struct sockaddr *src)
{
	struct sockaddr_in6 *sin6;

	sin6 = satosin6(sockaddr_copy(dst, socklen, src));

	if (sin6 == NULL || sa6_recoverscope(sin6) != 0)
		return NULL;

	return dst;
}
Пример #13
0
void
StunClient_HandleICMP(STUN_CLIENT_DATA*      clientData,
                      const struct sockaddr* srcAddr,
                      uint32_t               ICMPtype)
{
  if (clientData == NULL)
  {
    return;
  }
  /* Todo: Test if this is for me.. */
  StunPrint(clientData->logUserData,
            clientData->Log_cb,
            StunInfoCategory_Trace,
            "<STUNTRACE> StunClient_HandleICMP: Got ICMP type: %i\n ",
            ICMPtype);

  if ( isTimeExceeded(ICMPtype, srcAddr->sa_family) ||
       isDstUnreachable(ICMPtype,srcAddr->sa_family) )
  {
    for (int i = 0; i < MAX_STUN_TRANSACTIONS; i++)
    {
      STUN_TRANSACTION_DATA* trans = &clientData->data[i];
      if ( trans->inUse &&
           TransIdIsEqual(&clientData->traceResult.currStunMsgId,
                          &trans->stunBindReq.transactionId) )
      {
        StunRespStruct m;
        gettimeofday(&trans->stop[trans->retransmits], NULL);
        /* memcpy(&m.stunRespMessage, msg, sizeof(m.stunRespMessage)); */
        sockaddr_copy( (struct sockaddr*)&m.srcAddr, srcAddr );
        m.ICMPtype = ICMPtype;
        m.ttl      = clientData->traceResult.currentTTL;
        StunClientMain(clientData, i, STUN_SIGNAL_ICMPResp, (void*)&m);
        return;

      }
    }
  }
  else
  {
    StunPrint(clientData->logUserData,
              clientData->Log_cb,
              StunInfoCategory_Trace,
              "<STUNTRACE> StunClient_HandleICMP: Ignoring ICMP Type, nothing to do\n ",
              ICMPtype);
  }
}
Пример #14
0
static int SendRawStun(int sockfd, 
                       uint8_t *buf, 
                       int len, 
                       struct sockaddr *addr,
                       bool useRelay)
{
    char addr_str[SOCKADDR_MAX_STRLEN];
    /* find the transaction id  so we can use this in the simulated resp */

    memcpy(&LastTransId, &buf[8], STUN_MSG_ID_SIZE); 

    sockaddr_copy((struct sockaddr *)&LastAddress, addr);
    
    sockaddr_toString(addr, addr_str, SOCKADDR_MAX_STRLEN, true);
                      
    //printf("Sendto: '%s'\n", addr_str);

}
Пример #15
0
struct rtp_socket_t* rtp_socket_create(const char* name, struct sockaddr* allowed_remote_end_point) {
    
    struct rtp_socket_t* rs = (struct rtp_socket_t*)malloc(sizeof(struct rtp_socket_t));
    bzero(rs, sizeof(struct rtp_socket_t));
    
    if (allowed_remote_end_point != NULL)
        rs->allowed_remote_end_point = sockaddr_copy(allowed_remote_end_point);
    
    if (name) {
        rs->name = (char*)malloc(strlen(name) + 1);
        strcpy(rs->name, name);
    }
    
    rs->mutex = mutex_create();
    
    return rs;
    
}
Пример #16
0
END_TEST

START_TEST (sockaddr_IPv4_copy)
{
    struct sockaddr_storage copy;

    sockaddr_copy((struct sockaddr *)&copy,
                  (const struct sockaddr *)sockaddr_IPv4_1);

    fail_unless( sockaddr_alike((struct sockaddr *)&copy,
                                (struct sockaddr *)sockaddr_IPv4_1),
                 "copy failed");

    fail_if( sockaddr_alike((struct sockaddr *)&copy,
                            (struct sockaddr *)sockaddr_IPv4_2),
                 "copy failed");


}
Пример #17
0
void socket_connect(struct socket_t* s, struct sockaddr* end_point) {
    
    if (!s->is_connected && !s->is_udp) {
        
        if (s->socket <= 0)
            s->socket = socket(end_point->sa_family, SOCK_STREAM, IPPROTO_TCP);
        
        if (s->socket <= 0)
            log_message(LOG_ERROR, "Socket creation error: %s", strerror(errno));
        
        if (s->remote_end_point != NULL)
            sockaddr_destroy(s->remote_end_point);
        
        s->remote_end_point = sockaddr_copy(end_point);
        
        s->receive_thread = thread_create(_socket_connect, s);
        
    }
    
}
Пример #18
0
bool socket_bind(struct socket_t* s, struct sockaddr* end_point) {
    
    assert(end_point != NULL);
    
    if (s->local_end_point != NULL) {
        sockaddr_destroy(s->local_end_point);
        s->local_end_point = NULL;
    }
    
    struct sockaddr* ep = sockaddr_copy(end_point);
    s->local_end_point = ep;
    
    if (s->socket < 0) {
        
        s->socket = socket(ep->sa_family, (s->is_udp ? SOCK_DGRAM : SOCK_STREAM), (s->is_udp ? IPPROTO_UDP : IPPROTO_TCP));
        
        if (s->socket < 0) {
            log_message(LOG_ERROR, "Socket creation error: %s", strerror(errno));
            return false;
        }
        
        if (sockaddr_is_ipv6(ep)) {
            int32_t on = 1;
            setsockopt(s->socket, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on));
        }
        
    }
    
    if (!s->is_udp) {
        int so_reuseaddr = 1;
        setsockopt(s->socket, SOL_SOCKET, SO_REUSEADDR, &so_reuseaddr, sizeof(int));
    }
    
    if (bind(s->socket, ep, ep->sa_len) == 0)
        return true;
    
    
    return false;
    
}
Пример #19
0
rtp_socket_p _rtp_recorder_create_socket(struct rtp_recorder_t* rr, const char* name, struct sockaddr* local_end_point, struct sockaddr* remote_end_point) {
    
    rtp_socket_p ret = rtp_socket_create(name, remote_end_point);
    
    unsigned short p;
    for (p = 6000 ; p < 6100 ; p++) {
        struct sockaddr* ep = sockaddr_copy(local_end_point);
        sockaddr_set_port(ep, p);
        if (rtp_socket_setup(ret, ep)) {
            rtp_socket_set_data_received_callback(ret, _rtp_recorder_socket_data_received_callback, rr);
            log_message(LOG_INFO, "Setup socket on port %u", p);
            sockaddr_destroy(ep);
            return ret;
        }
        sockaddr_destroy(ep);
    }
    
    log_message(LOG_ERROR, "Unable to bind socket.");
    
    rtp_socket_destroy(ret);
    
    return NULL;
    
}
Пример #20
0
void _socket_receive_loop(void* ctx) {
    
    struct socket_t* s = (struct socket_t*)ctx;
    
    mutex_lock(s->mutex);
    _socket_set_loop_name(s, "Receive Loop");
    
    s->is_connected = true;
    
    void* buffer = NULL;
    size_t buffer_size = 0;
    size_t write_pos = 0;
    ssize_t processed = 0;
    
    ssize_t read = 0;
    
    do {
        
        if (buffer_size - write_pos < 16384) {
            buffer_size += 16384;
            buffer = realloc(buffer, buffer_size);
        }
        
        if (s->is_udp) {
            
            struct sockaddr_storage remote_addr;
            socklen_t remote_addr_len = sizeof(struct sockaddr_storage);
            mutex_unlock(s->mutex);
            read = recvfrom(s->socket, buffer + write_pos, buffer_size - write_pos, 0, (struct sockaddr*) &remote_addr, &remote_addr_len);
            mutex_lock(s->mutex);
            
            if (s->remote_end_point != NULL) {
                sockaddr_destroy(s->remote_end_point);
                s->remote_end_point = NULL;
            }
            
            s->remote_end_point = sockaddr_copy((struct sockaddr*) &remote_addr);
            
        } else {
            mutex_unlock(s->mutex);
            read = recv(s->socket, buffer + write_pos, buffer_size - write_pos, 0);
            mutex_lock(s->mutex);
        }
        
        if (read > 0) {
            
            write_pos += read;
            processed = write_pos;
            
            if (s->callbacks.receive != NULL) {
                mutex_unlock(s->mutex);
                processed = s->callbacks.receive(s, buffer, write_pos, s->remote_end_point, s->callbacks.ctx.receive);
                mutex_lock(s->mutex);
            }
            
            if (processed > 0) {
                memcpy(buffer, buffer + processed, write_pos - processed);
                write_pos -= processed;
            }
            
        }
        
    } while (read > 0 && processed >= 0);
    
    if (buffer != NULL)
        free(buffer);
    
    mutex_unlock(s->mutex);
    
    socket_close(s);
    
}
Пример #21
0
int revname(int *lookup, struct sockaddr_storage *addr,
	    char *target, size_t target_size, int rvnfd)
{
	struct rvn rpkt;
	int br;
	struct sockaddr_un su;
	socklen_t fl;
	fd_set sockset;
	struct timeval tv;
	int sstat = 0;

	memset(target, 0, target_size);
	if (*lookup) {
		if (rvnfd > 0) {
			su.sun_family = AF_UNIX;
			strcpy(su.sun_path, IPTSOCKNAME);

			rpkt.type = RVN_REQUEST;
			sockaddr_copy(&rpkt.addr, addr);

			sendto(rvnfd, &rpkt, sizeof(struct rvn), 0,
			       (struct sockaddr *) &su,
			       sizeof(su.sun_family) + strlen(su.sun_path));

			fl = sizeof(su.sun_family) + strlen(su.sun_path);
			do {
				tv.tv_sec = 10;
				tv.tv_usec = 0;

				FD_ZERO(&sockset);
				FD_SET(rvnfd, &sockset);

				do {
					sstat =
					    select(rvnfd + 1, &sockset, NULL,
						   NULL, &tv);
				} while ((sstat < 0) && (errno == EINTR));

				if (FD_ISSET(rvnfd, &sockset))
					br = recvfrom(rvnfd, &rpkt,
						      sizeof(struct rvn), 0,
						      (struct sockaddr *) &su,
						      &fl);
				else
					br = -1;
			} while ((br < 0) && (errno == EINTR));

			if (br < 0) {
				sockaddr_ntop(addr, target, target_size);
				printipcerr();
				*lookup = 0;
				return RESOLVED;
			}
			strncpy(target, rpkt.fqdn, target_size - 1);
			return (rpkt.ready);
		} else {
			struct hostent *he = sockaddr_gethostbyaddr(addr);
			if (he == NULL) {
				sockaddr_ntop(addr, target, target_size);
			} else {
				strncpy(target, he->h_name, target_size - 1);
			}

			return RESOLVED;
		}
	} else {
		sockaddr_ntop(addr, target, target_size);
		return RESOLVED;
	}
	return NOTRESOLVED;
}
Пример #22
0
int
StunTrace_startTrace(STUN_CLIENT_DATA*      clientData,
                     void*                  userCtx,
                     const struct sockaddr* toAddr,
                     const struct sockaddr* fromAddr,
                     uint32_t               sockhandle,
                     const char*            ufrag,
                     const char*            password,
                     uint32_t               numTraces,
                     STUN_TRACECB           traceCbFunc,
                     STUN_SENDFUNC          sendFunc)
{
  if (clientData == NULL)
  {
    return 0;
  }
  if (!sendFunc || !toAddr)
  {
    return 0;
  }
  struct hiutResult* result;

  result = &clientData->traceResult;

  result->currentTTL = MAX_TTL;
  result->userCtx    = userCtx;
  stunlib_createId(&result->currStunMsgId);
  result->stunCtx = clientData;
  /* Fill inn the hiut struct so we get something back in the CB */
  /* TODO: Fix the struct so we do not store information twice!! */
  sockaddr_copy( (struct sockaddr*)&clientData->traceResult.localAddr,
                 fromAddr );
  sockaddr_copy( (struct sockaddr*)&clientData->traceResult.remoteAddr,
                 toAddr );

  result->user_max_ttl         = 40;
  result->user_start_ttl       = 1;
  result->wait_ms              = 0;
  result->max_recuring         = numTraces;
  result->user_paralell_traces = 0;
  result->path_max_ttl         = 255;
  result->num_traces           = 1;
  result->traceCb              = traceCbFunc;
  result->sendFunc             = sendFunc;
  result->sockfd               = sockhandle;

  strncpy(result->username, ufrag,    sizeof(result->username) - 1);
  strncpy(result->password, password, sizeof(result->password) - 1);

  StunClient_startSTUNTrace(result->stunCtx,
                            result,
                            toAddr,
                            fromAddr,
                            false,
                            result->username,
                            result->password,
                            result->currentTTL,
                            result->currStunMsgId,
                            result->sockfd,
                            result->sendFunc,
                            StunStatusCallBack,
                            NULL);
  return 1;

}
Пример #23
0
struct othptabent *add_othp_entry(struct othptable *table, struct pkt_hdr *pkt,
				  struct sockaddr_storage *saddr,
				  struct sockaddr_storage *daddr,
				  int is_ip,
				  int protocol,
				  char *packet2,
				  char *ifname, int *rev_lookup, int rvnfd,
				  int logging, FILE *logfile, int fragment)
{
	struct othptabent *new_entry;
	struct othptabent *temp;

	new_entry = xmallocz(sizeof(struct othptabent));

	new_entry->is_ip = is_ip;
	new_entry->fragment = fragment;

	if (options.mac || !is_ip) {
		if (pkt->pkt_hatype == ARPHRD_ETHER) {
			convmacaddr((char *) pkt->ethhdr->h_source, new_entry->smacaddr);
			convmacaddr((char *) pkt->ethhdr->h_dest, new_entry->dmacaddr);
		} else if (pkt->pkt_hatype == ARPHRD_FDDI) {
			convmacaddr((char *) pkt->fddihdr->saddr, new_entry->smacaddr);
			convmacaddr((char *) pkt->fddihdr->daddr, new_entry->dmacaddr);
		}
	}

	if (is_ip) {
		sockaddr_copy(&new_entry->saddr, saddr);
		sockaddr_copy(&new_entry->daddr, daddr);

		revname(rev_lookup, saddr, new_entry->s_fqdn,
			sizeof(new_entry->s_fqdn), rvnfd);
		revname(rev_lookup, daddr, new_entry->d_fqdn,
			sizeof(new_entry->d_fqdn), rvnfd);

		if (!fragment) {
			if (protocol == IPPROTO_ICMP) {
				new_entry->un.icmp.type =
				    ((struct icmphdr *) packet2)->type;
				new_entry->un.icmp.code =
				    ((struct icmphdr *) packet2)->code;
			} else if (protocol == IPPROTO_ICMPV6) {
				new_entry->un.icmp6.type =
				    ((struct icmp6_hdr *) packet2)->icmp6_type;
				new_entry->un.icmp6.code =
				    ((struct icmp6_hdr *) packet2)->icmp6_code;
			} else if (protocol == IPPROTO_UDP) {
				servlook(ntohs(((struct udphdr *) packet2)->source),
					 IPPROTO_UDP, new_entry->un.udp.s_sname,
					 10);
				servlook(ntohs(((struct udphdr *) packet2)->dest),
					 IPPROTO_UDP, new_entry->un.udp.d_sname,
					 10);
			} else if (protocol == IPPROTO_OSPFIGP) {
				new_entry->un.ospf.type =
				    ((struct ospfhdr *) packet2)->ospf_type;
				new_entry->un.ospf.area =
				    ntohl(((struct ospfhdr *) packet2)->
					  ospf_areaid.s_addr);
				inet_ntop(AF_INET,
					  &((struct ospfhdr *)packet2)->ospf_routerid,
					  new_entry->un.ospf.routerid,
					  sizeof(new_entry->un.ospf.routerid));
			}
		}
	} else {
		new_entry->linkproto = pkt->pkt_hatype;

		if (protocol == ETH_P_ARP) {
			new_entry->un.arp.opcode =
			    ((struct arp_hdr *) packet2)->ar_op;
			memcpy(&(new_entry->un.arp.src_ip_address),
			       &(((struct arp_hdr *) packet2)->ar_sip), 4);
			memcpy(&(new_entry->un.arp.dest_ip_address),
			       &(((struct arp_hdr *) packet2)->ar_tip), 4);
		} else if (protocol == ETH_P_RARP) {
			new_entry->un.rarp.opcode =
			    ((struct arphdr *) packet2)->ar_op;
			memcpy(&(new_entry->un.rarp.src_mac_address),
			       &(((struct arp_hdr *) packet2)->ar_sha), 6);
			memcpy(&(new_entry->un.rarp.dest_mac_address),
			       &(((struct arp_hdr *) packet2)->ar_tha), 6);
		}
	}

	new_entry->protocol = protocol;
	strcpy(new_entry->iface, ifname);

	new_entry->pkt_length = pkt->pkt_len;

	if (table->head == NULL) {
		new_entry->prev_entry = NULL;
		table->head = new_entry;
		table->firstvisible = new_entry;
	}
	/*
	 * Max number of entries in the lower window is 512.  Upon reaching
	 * this figure, oldest entries are thrown out.
	 */

	if (table->count == 512) {
		if (table->firstvisible == table->head) {
			wscrl(table->othpwin, 1);
			printothpentry(table, table->lastvisible->next_entry,
				       table->oimaxy - 1, logging, logfile);
			table->firstvisible = table->firstvisible->next_entry;
			table->lastvisible = table->lastvisible->next_entry;
		}
		temp = table->head;
		table->head = table->head->next_entry;
		table->head->prev_entry = NULL;
		free(temp);
	} else
		table->count++;

	if (table->tail != NULL) {
		new_entry->prev_entry = table->tail;
		table->tail->next_entry = new_entry;
	}
	table->tail = new_entry;
	new_entry->next_entry = NULL;

	table->lastpos++;
	new_entry->index = table->lastpos;

	if (table->count <= table->oimaxy) {
		table->lastvisible = new_entry;
		printothpentry(table, new_entry, table->count - 1, logging,
			       logfile);
	} else if (table->lastvisible == table->tail->prev_entry) {
		wscrl(table->othpwin, 1);
		table->firstvisible = table->firstvisible->next_entry;
		table->lastvisible = table->tail;
		printothpentry(table, new_entry, table->oimaxy - 1, logging,
			       logfile);
	}
	return new_entry;
}
Пример #24
0
int createLocalUDPSocket(int ai_family,
                         const struct sockaddr *localIp,
                         struct sockaddr *hostaddr,
                         uint16_t port)
{
    int sockfd;

    int rv;
    int yes = 1;
    struct addrinfo hints, *ai, *p;
    char addr[SOCKADDR_MAX_STRLEN];
    char service[8];

    sockaddr_toString(localIp, addr, sizeof addr, false);

    //itoa(port, service, 10);

    snprintf(service, 8, "%d", port);
    //snprintf(service, 8, "%d", 3478);

        
    // get us a socket and bind it
    memset(&hints, 0, sizeof hints);
    hints.ai_family = ai_family;
    hints.ai_socktype = SOCK_DGRAM;
    hints.ai_flags = AI_NUMERICHOST | AI_ADDRCONFIG;

    
    if ((rv = getaddrinfo(addr, service, &hints, &ai)) != 0) {
        fprintf(stderr, "selectserver: %s ('%s')\n", gai_strerror(rv), addr);
        exit(1);
    }

    for (p = ai; p != NULL; p = p->ai_next) {

        if (sockaddr_isAddrAny(p->ai_addr) ){
            //printf("Ignoring any\n");
            continue;

        }
        
        if ((sockfd = socket(p->ai_family, p->ai_socktype,
                             p->ai_protocol)) == -1) {
            perror("client: socket");
            continue;
        }

                
                    
        if (bind(sockfd, p->ai_addr, p->ai_addrlen) < 0) {
            printf("Bind failed\n");
            close(sockfd);
            continue;
        }
    
        if (localIp != NULL){
            struct sockaddr_storage ss;
            socklen_t len = sizeof(ss);

            if (getsockname(sockfd, (struct sockaddr *)&ss, &len) == -1){
                perror("getsockname");
            }
            else{
                if (ss.ss_family == AF_INET) {
                    ((struct sockaddr_in *)p->ai_addr)->sin_port = ((struct sockaddr_in *)&ss)->sin_port;
                }else{
                    ((struct sockaddr_in6 *)p->ai_addr)->sin6_port = ((struct sockaddr_in6 *)&ss)->sin6_port;
                }
            }
            
            
            sockaddr_copy(hostaddr, p->ai_addr);
            
            
            //printf("Bound to: '%s'\n",
            //       sockaddr_toString(localIp, addr, sizeof(addr), true));
            
        }
        
        break;
    }
    
    return sockfd;
}
Пример #25
0
struct tcptableent *addentry(struct tcptable *table,
			     struct sockaddr_storage *saddr,
			     struct sockaddr_storage *daddr,
			     int protocol, char *ifname,
			     int *rev_lookup, int rvnfd)
{
	struct tcptableent *new_entry;
	struct closedlist *ctemp;

	/*
	 * Allocate and attach a new node if no closed entries found
	 */

	if (table->closedentries == NULL) {
		new_entry = xmalloc(sizeof(struct tcptableent));
		new_entry->oth_connection = xmalloc(sizeof(struct tcptableent));

		new_entry->oth_connection->oth_connection = new_entry;

		if (table->head == NULL) {
			new_entry->prev_entry = NULL;
			table->head = new_entry;

			table->firstvisible = new_entry;
		}
		if (table->tail != NULL) {
			table->tail->next_entry = new_entry;
			new_entry->prev_entry = table->tail;
		}
		table->lastpos++;
		new_entry->index = table->lastpos;
		table->lastpos++;
		new_entry->oth_connection->index = table->lastpos;

		table->tail = new_entry->oth_connection;
		new_entry->next_entry = new_entry->oth_connection;
		new_entry->next_entry->prev_entry = new_entry;
		new_entry->next_entry->next_entry = NULL;


		if (new_entry->oth_connection->index <=
		    table->firstvisible->index + (table->imaxy - 1))
			table->lastvisible = new_entry->oth_connection;
		else if (new_entry->index <=
			 table->firstvisible->index + (table->imaxy - 1))
			table->lastvisible = new_entry;

		new_entry->reused = new_entry->oth_connection->reused = 0;
		table->count++;

		rate_alloc(&new_entry->rate, 5);
		rate_alloc(&new_entry->oth_connection->rate, 5);

		print_tcp_num_entries(table);
	} else {
		/*
		 * If we reach this point, we're allocating off the list of closed
		 * entries.  In this case, we take the top entry, let the new_entry
		 * variable point to whatever the top is pointing to.  The new_entry's
		 * oth_connection also points to the reused entry's oth_connection
		 */

		new_entry = table->closedentries->closedentry;
		new_entry->oth_connection = table->closedentries->pair;

		ctemp = table->closedentries;
		table->closedentries = table->closedentries->next_entry;
		free(ctemp);

		/*
		 * Mark the closed list's tail as NULL if we use the last entry
		 * in the list to prevent a dangling reference.
		 */

		if (table->closedentries == NULL)
			table->closedtail = NULL;

		new_entry->reused = new_entry->oth_connection->reused = 1;

		/*
		 * Delete the old hash entries for this reallocated node;
		 */

		del_tcp_hash_node(table, new_entry);
		del_tcp_hash_node(table, new_entry->oth_connection);
	}

	/*
	 * Fill in address fields with raw IP addresses
	 */

	sockaddr_copy(&new_entry->saddr, saddr);
	sockaddr_copy(&new_entry->oth_connection->daddr, saddr);
	sockaddr_copy(&new_entry->daddr, daddr);
	sockaddr_copy(&new_entry->oth_connection->saddr, daddr);
	new_entry->protocol = protocol;

	/*
	 * Initialize count fields
	 */

	new_entry->pcount = new_entry->bcount = 0;
	new_entry->win = new_entry->psize = 0;
	new_entry->timedout = new_entry->oth_connection->timedout = 0;
	new_entry->oth_connection->pcount = new_entry->oth_connection->bcount =
	    0;
	new_entry->oth_connection->win = new_entry->oth_connection->psize = 0;

	/*
	 * Store interface name
	 */

	strcpy(new_entry->ifname, ifname);
	strcpy(new_entry->oth_connection->ifname, ifname);

	/*
	 * Zero out MAC address fields
	 */

	memset(new_entry->smacaddr, 0, sizeof(new_entry->smacaddr));
	memset(new_entry->oth_connection->smacaddr, 0, sizeof(new_entry->oth_connection->smacaddr));

	new_entry->stat = new_entry->oth_connection->stat = 0;

	new_entry->s_fstat =
	    revname(rev_lookup, &new_entry->saddr,
		    new_entry->s_fqdn, sizeof(new_entry->s_fqdn), rvnfd);

	new_entry->d_fstat =
	    revname(rev_lookup, &new_entry->daddr,
		    new_entry->d_fqdn, sizeof(new_entry->d_fqdn), rvnfd);

	/* set port service names (where applicable) */
	servlook(sockaddr_get_port(saddr), IPPROTO_TCP, new_entry->s_sname, 10);
	servlook(sockaddr_get_port(daddr), IPPROTO_TCP, new_entry->d_sname, 10);

	strcpy(new_entry->oth_connection->s_sname, new_entry->d_sname);
	strcpy(new_entry->oth_connection->d_sname, new_entry->s_sname);

	strcpy(new_entry->oth_connection->d_fqdn, new_entry->s_fqdn);
	strcpy(new_entry->oth_connection->s_fqdn, new_entry->d_fqdn);
	new_entry->oth_connection->s_fstat = new_entry->d_fstat;
	new_entry->oth_connection->d_fstat = new_entry->s_fstat;

	if (new_entry->index < new_entry->oth_connection->index) {
		new_entry->half_bracket = ACS_ULCORNER;
		new_entry->oth_connection->half_bracket = ACS_LLCORNER;
	} else {
		new_entry->half_bracket = ACS_LLCORNER;
		new_entry->oth_connection->half_bracket = ACS_ULCORNER;
	}

	new_entry->inclosed = new_entry->oth_connection->inclosed = 0;
	new_entry->finack = new_entry->oth_connection->finack = 0;
	new_entry->finsent = new_entry->oth_connection->finsent = 0;
	new_entry->partial = new_entry->oth_connection->partial = 0;
	new_entry->spanbr = new_entry->oth_connection->spanbr = 0;
	new_entry->conn_starttime = new_entry->oth_connection->conn_starttime =
	    time(NULL);

	rate_init(&new_entry->rate);
	rate_init(&new_entry->oth_connection->rate);

	/*
	 * Mark flow rate start time and byte counter for flow computation
	 * if the highlight bar is on either flow of the new connection.
	 */
	if (table->barptr == new_entry) {
		new_entry->starttime = time(NULL);
		new_entry->spanbr = 0;
	} else if (table->barptr == new_entry->oth_connection) {
		new_entry->oth_connection->starttime = time(NULL);
		new_entry->oth_connection->spanbr = 0;
	}

	/*
	 * Add entries to hash table
	 */

	add_tcp_hash_entry(table, new_entry);
	add_tcp_hash_entry(table, new_entry->oth_connection);

	return new_entry;
}