diff --git a/include/stun_intern.h b/include/stun_intern.h index 16cd89a..31b3c2f 100644 --- a/include/stun_intern.h +++ b/include/stun_intern.h @@ -59,22 +59,24 @@ typedef struct { struct sockaddr_storage serverAddr; struct sockaddr_storage baseAddr; bool useRelay; - char ufrag[300]; /* TBD = ICE_MAX_UFRAG_LENGTH*/ - char password[300]; /* TBD = ICE_MAX_PASSWD_LENGTH*/ - uint32_t peerPriority; - bool useCandidate; - bool iceControlling; - uint64_t tieBreaker; - uint32_t proto; - uint8_t ttl; - StunMsgId transactionId; - uint32_t sockhandle; - STUN_SENDFUNC sendFunc; - STUNCB stunCbFunc; - DiscussData* discussData; /*NULL allowed if none present */ - bool addSoftware; - bool stuntrace; - bool addTransCnt; + /* char ufrag[300]; / * TBD = + * ICE_MAX_UFRAG_LENGTH* / */ + /* char password[300]; / * TBD = ICE_MAX_PASSWD_LENGTH* / */ + /* uint32_t peerPriority; */ + /* bool useCandidate; */ + /* bool iceControlling; */ + /* uint64_t tieBreaker; */ + uint32_t proto; + uint8_t ttl; + /* StunMsgId transactionId; */ + /* uint32_t sockhandle; */ + TransactionAttributes transAttr; + STUN_SENDFUNC sendFunc; + STUNCB stunCbFunc; + + bool addSoftware; + bool stuntrace; + bool addTransCnt; } StunBindReqStruct; struct StunClientStats @@ -127,8 +129,7 @@ typedef struct /* uint32_t ttl; */ /* DISCUSS */ - bool hasDiscuss; - DiscussData discussData; + bool hasDiscuss; struct StunClientStats stats; STUN_CLIENT_DATA* client; diff --git a/include/stunclient.h b/include/stunclient.h index e630b22..8c84a32 100644 --- a/include/stunclient.h +++ b/include/stunclient.h @@ -171,31 +171,21 @@ StunClient_startBindTransaction(STUN_CLIENT_DATA* clientData, 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, + TransactionAttributes* transAttr, STUN_SENDFUNC sendFunc, - STUNCB stunCbFunc, - DiscussData* discussData); + STUNCB stunCbFunc); + void 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, + TransactionAttributes* transAttr, STUN_SENDFUNC sendFunc, - STUNCB stunCbFunc, - DiscussData* discussData); + STUNCB stunCbFunc); + /* * This function must be called by the application every N msec. N must be same * as in StunClientBind_Init(instances, N) diff --git a/include/stunlib.h b/include/stunlib.h index cc3a1c5..217427a 100644 --- a/include/stunlib.h +++ b/include/stunlib.h @@ -84,16 +84,9 @@ extern "C" { /*Path Discovery test attribute */ #define STUN_ATTR_PD 0x8041 -/*DISCUSS Draft Attributes */ -#define STUN_ATTR_StreamType 0x8050 -#define STUN_ATTR_NetworkStatus 0x8051 -#define STUN_ATTR_BandwidthUsage 0x8052 - -/* STUN CISCO Extensions */ -#define STUN_ATTR_Cisco_Network_Feedback 0xC001 - -/* STUN CISCO Extensions */ -#define STUN_ATTR_Cisco_Network_Feedback 0xC001 +/*ENF Draft Attributes */ +#define STUN_ATTR_EnfFlowDescription 0xC001 +#define STUN_ATTR_EnfNetworkStatus 0xC002 /*STUNTrace Attributes (Experimental) */ #define STUN_ATTR_TTL 0x8055 @@ -192,6 +185,8 @@ extern "C" { * * * + * + * *msec **/ #define STUNCLIENT_DFLT_TICK_TIMER_MS 50 @@ -350,11 +345,14 @@ StunAtrEvenPort; typedef struct { - uint16_t type; - uint8_t interactivity; + /*4 bits*/ + uint8_t type; + /*4 bits*/ + uint8_t tbd; + uint16_t bandwidthMax; uint8_t pad; } -StunAtrStreamType; +StunAtrEnfFlowDescription; typedef struct { @@ -364,7 +362,7 @@ typedef struct uint16_t upMaxBandwidth; uint16_t downMaxBandwidth; } -StunAtrNetworkStatus; +StunAtrEnfNetworkStatus; typedef struct { @@ -374,14 +372,6 @@ typedef struct } StunAtrTransCount; -typedef struct -{ - uint32_t first; - uint32_t second; - uint32_t third; -} -StunAtrCiscoNetworkFeedback; - typedef struct { uint16_t average; @@ -410,31 +400,27 @@ typedef struct - typedef struct { - uint16_t streamType; - uint8_t interactivity; - - uint16_t bandwidthUsage_average; - uint16_t bandwidthUsage_max; - - uint8_t networkStatus_flags; - uint8_t networkStatus_nodeCnt; - uint16_t networkStatus_tbd; - uint16_t networkStatus_upMaxBandwidth; - uint16_t networkStatus_downMaxBandwidth; - - /*Ugh, maybee own structs? Will be Integrity protected*/ - uint8_t networkStatusResp_flags; - uint8_t networkStatusResp_nodeCnt; - uint16_t networkStatusResp_tbd; - uint16_t networkStatusResp_upMaxBandwidth; - uint16_t networkStatusResp_downMaxBandwidth; - - - -} DiscussData; + /* Core Values*/ + StunMsgId transactionId; + uint32_t sockhandle; + /* ICE Related */ + char username[STUN_MSG_MAX_USERNAME_LENGTH]; + char password[STUN_MSG_MAX_PASSWORD_LENGTH]; + uint32_t peerPriority; + bool useCandidate; + bool iceControlling; + uint64_t tieBreaker; + /* ENF */ + bool addEnf; + StunAtrEnfFlowDescription enfFlowDescription; + StunAtrEnfNetworkStatus enfNetworkStatus; + StunAtrEnfNetworkStatus enfNetworkStatusResp; + + /* MISC */ + +} TransactionAttributes; /* Decoded STUN message */ @@ -531,28 +517,19 @@ typedef struct bool hasReservationToken; StunAtrDoubleValue reservationToken; - bool hasStreamType; - StunAtrStreamType streamType; - - bool hasBandwidthUsage; - StunAtrBandwidthUsage bandwidthUsage; + bool hasEnfFlowDescription; + StunAtrEnfFlowDescription enfFlowDescription; bool hasTTL; StunAtrTTL ttl; /*After Integrity attr*/ - bool hasNetworkStatus; - StunAtrNetworkStatus networkStatus; - - bool hasCiscoNetFeed; - StunAtrCiscoNetworkFeedback ciscoNetFeed; + bool hasEnfNetworkStatus; + StunAtrEnfNetworkStatus enfNetworkStatus; /*Integrity protected*/ - bool hasNetworkStatusResp; - StunAtrNetworkStatus networkStatusResp; - - bool hasCiscoNetFeedResp; - StunAtrCiscoNetworkFeedback ciscoNetFeedResp; + bool hasEnfNetworkStatusResp; + StunAtrEnfNetworkStatus enfNetworkStatusResp; bool hasTransCount; StunAtrTransCount transCount; diff --git a/include/stunserver.h b/include/stunserver.h index 2494e04..2709b71 100644 --- a/include/stunserver.h +++ b/include/stunserver.h @@ -17,14 +17,19 @@ extern "C" { #endif bool - CreateConnectivityBindingResp(StunMessage * stunMsg, - StunMsgId transactionId, - const struct sockaddr* mappedSockAddr, - uint8_t reqTrnspCnt, - uint8_t respTrnspCnt, - uint16_t response, - uint32_t responseCode, - DiscussData * discussData); + CreateConnectivityBindingResp(StunMessage* stunMsg, + StunMsgId transactionId, + const struct sockaddr* mappedSockAddr, + uint8_t reqTrnspCnt, + uint8_t respTrnspCnt, + uint8_t enf_flags, + uint8_t enf_nodeCnt, + uint16_t enf_upMaxBandwidth, + uint16_t enf_downMaxBandwidth, + uint16_t response, + uint32_t responseCode); + + /********* Server handling: send STUN BIND RESP *************/ bool StunServer_SendConnectivityBindingResp(STUN_CLIENT_DATA * clientData, @@ -35,12 +40,15 @@ extern "C" { const struct sockaddr* dstAddr, uint8_t reqTrnspCnt, uint8_t respTrnspCnt, + uint8_t enf_flags, + uint8_t enf_nodeCnt, + uint16_t enf_upMaxBandwidth, + uint16_t enf_downMaxBandwidth, void* userData, STUN_SENDFUNC sendFunc, int proto, bool useRelay, - uint32_t responseCode, - DiscussData * discussData); + uint32_t responseCode); /********** Server handling: incoming STUN BIND REQ **********/ bool diff --git a/include/stuntrace.h b/include/stuntrace.h index 0be12b5..b0aa277 100644 --- a/include/stuntrace.h +++ b/include/stuntrace.h @@ -40,21 +40,22 @@ struct hiutPathElement { struct hiutResult { /* STUN Setup */ - void* stunCtx; - void* userCtx; - int32_t sockfd; - char username[STUN_MSG_MAX_USERNAME_LENGTH]; - char password[STUN_MSG_MAX_PASSWORD_LENGTH]; + void* stunCtx; + void* userCtx; + TransactionAttributes transAttr; + /* int32_t sockfd; */ + /* char username[STUN_MSG_MAX_USERNAME_LENGTH]; */ + /* char password[STUN_MSG_MAX_PASSWORD_LENGTH]; */ STUN_SENDFUNC sendFunc; - int32_t currentTTL; - StunMsgId currStunMsgId; - int32_t user_start_ttl; - int32_t user_max_ttl; - int32_t user_paralell_traces; - int32_t path_max_ttl; /*got port unreachable or STUN response + int32_t currentTTL; + /* StunMsgId currStunMsgId; */ + int32_t user_start_ttl; + int32_t user_max_ttl; + int32_t user_paralell_traces; + int32_t path_max_ttl; /*got port unreachable or STUN response **/ uint32_t wait_ms; struct sockaddr_storage localAddr; diff --git a/include/turn_intern.h b/include/turn_intern.h index 36aa9af..fa0b8e5 100644 --- a/include/turn_intern.h +++ b/include/turn_intern.h @@ -108,7 +108,7 @@ struct TURN_INSTANCE_DATA TurnAllocateReqStuct turnAllocateReq; StunMsgId StunReqTransId; /* transaction * id of - *request + * request **/ StunMsgId PrevRespTransId; /* transaction * id of last diff --git a/include/turnclient.h b/include/turnclient.h index b8f82a1..29555c1 100644 --- a/include/turnclient.h +++ b/include/turnclient.h @@ -114,8 +114,8 @@ TurnStats_T; /* Defines how a user of turn sends data on e.g. socket */ typedef void (* TURN_SEND_FUNC)(const uint8_t* buffer, /* ptr to - * buffer to - * send */ + * buffer to + * send */ size_t bufLen, /* length of * send * buffer */ diff --git a/src/stunclient.c b/src/stunclient.c index 566adc1..7f98c5f 100644 --- a/src/stunclient.c +++ b/src/stunclient.c @@ -150,36 +150,36 @@ BuildStunBindReq(STUN_TRANSACTION_DATA* trans, stunReqMsg->msgHdr.msgType = STUN_MSG_BindRequestMsg; /* transaction id */ - memcpy( &stunReqMsg->msgHdr.id, &trans->stunBindReq.transactionId, + memcpy( &stunReqMsg->msgHdr.id, &trans->stunBindReq.transAttr.transactionId, sizeof(StunMsgId) ); /* Username */ - if (strlen(trans->stunBindReq.ufrag) > 0) + if (strlen(trans->stunBindReq.transAttr.username) > 0) { stunReqMsg->hasUsername = true; strncpy(stunReqMsg->username.value, - trans->stunBindReq.ufrag, + trans->stunBindReq.transAttr.username, STUN_MAX_STRING - 1); stunReqMsg->username.sizeValue = - min( STUN_MAX_STRING, strlen(trans->stunBindReq.ufrag) ); + min( STUN_MAX_STRING, strlen(trans->stunBindReq.transAttr.username) ); } /* Priority */ - if (trans->stunBindReq.peerPriority > 0) + if (trans->stunBindReq.transAttr.peerPriority > 0) { stunReqMsg->hasPriority = true; - stunReqMsg->priority.value = trans->stunBindReq.peerPriority; + stunReqMsg->priority.value = trans->stunBindReq.transAttr.peerPriority; } /* useCandidate */ - stunReqMsg->hasUseCandidate = trans->stunBindReq.useCandidate; + stunReqMsg->hasUseCandidate = trans->stunBindReq.transAttr.useCandidate; /* controlling */ - if (trans->stunBindReq.tieBreaker > 0) + if (trans->stunBindReq.transAttr.tieBreaker > 0) { - stunReqMsg->hasControlling = trans->stunBindReq.iceControlling; - stunReqMsg->controlling.value = trans->stunBindReq.tieBreaker; - if (!trans->stunBindReq.iceControlling) + stunReqMsg->hasControlling = trans->stunBindReq.transAttr.iceControlling; + stunReqMsg->controlling.value = trans->stunBindReq.transAttr.tieBreaker; + if (!trans->stunBindReq.transAttr.iceControlling) { stunReqMsg->hasControlled = true; - stunReqMsg->controlled.value = trans->stunBindReq.tieBreaker; + stunReqMsg->controlled.value = trans->stunBindReq.transAttr.tieBreaker; } } /* ttl */ @@ -189,27 +189,6 @@ BuildStunBindReq(STUN_TRANSACTION_DATA* trans, stunReqMsg->ttl.ttl = trans->stunBindReq.ttl; } - - /*Adding DISCUSS attributes if present*/ - if (trans->stunBindReq.discussData != NULL) - { - stunReqMsg->hasStreamType = true; - stunReqMsg->streamType.type = - trans->stunBindReq.discussData->streamType; - stunReqMsg->streamType.interactivity = - trans->stunBindReq.discussData->interactivity; - - stunReqMsg->hasNetworkStatus = true; - stunReqMsg->networkStatus.flags = - trans->stunBindReq.discussData->networkStatus_flags; - stunReqMsg->networkStatus.nodeCnt = - trans->stunBindReq.discussData->networkStatus_nodeCnt; - stunReqMsg->networkStatus.upMaxBandwidth = - trans->stunBindReq.discussData->networkStatus_upMaxBandwidth; - stunReqMsg->networkStatus.downMaxBandwidth = - trans->stunBindReq.discussData->networkStatus_downMaxBandwidth; - } - if (trans->stunBindReq.addSoftware) { stunlib_addSoftware(stunReqMsg, SoftwareVersionStr, STUN_DFLT_PAD); @@ -222,6 +201,20 @@ BuildStunBindReq(STUN_TRANSACTION_DATA* trans, stunReqMsg->transCount.reqCnt = (uint8_t)trans->retransmits + 1; stunReqMsg->transCount.respCnt = (uint8_t)0; } + + /* Add optional Tranaction Attributes */ + if (trans->stunBindReq.transAttr.addEnf) + { + stunReqMsg->hasEnfFlowDescription = true; + memcpy( &stunReqMsg->enfFlowDescription, + &trans->stunBindReq.transAttr.enfFlowDescription, + sizeof(StunAtrEnfFlowDescription) ); + + /* And add empty attribute after Integrity Attribute to carry Feedback */ + /* from the network */ + stunReqMsg->hasEnfNetworkStatus = true; + memset( &stunReqMsg->enfNetworkStatus, 0,sizeof(StunAtrEnfNetworkStatus) ); + } } @@ -317,17 +310,9 @@ StunClient_startBindTransaction(STUN_CLIENT_DATA* clientData, 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, + TransactionAttributes* transAttr, STUN_SENDFUNC sendFunc, - STUNCB stunCbFunc, - DiscussData* discussData) + STUNCB stunCbFunc) { StunBindReqStruct m; @@ -340,19 +325,12 @@ StunClient_startBindTransaction(STUN_CLIENT_DATA* clientData, 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; + memcpy( &m.transAttr, transAttr, sizeof(TransactionAttributes) ); + + m.proto = proto; + m.useRelay = useRelay; + m.sendFunc = sendFunc; + m.addSoftware = true; /*TODO: Let app overide this */ m.addTransCnt = true; @@ -371,15 +349,10 @@ StunClient_startSTUNTrace(STUN_CLIENT_DATA* clientData, const struct sockaddr* serverAddr, const struct sockaddr* baseAddr, bool useRelay, - const char* ufrag, - const char* password, uint8_t ttl, - StunMsgId transactionId, - uint32_t sockhandle, + TransactionAttributes* transAttr, STUN_SENDFUNC sendFunc, - STUNCB stunCbFunc, - DiscussData* discussData) /*NULL if - * none*/ + STUNCB stunCbFunc) { StunBindReqStruct m; @@ -390,22 +363,18 @@ StunClient_startSTUNTrace(STUN_CLIENT_DATA* clientData, m.userCtx = userCtx; sockaddr_copy( (struct sockaddr*)&m.serverAddr, serverAddr ); sockaddr_copy( (struct sockaddr*)&m.baseAddr, baseAddr ); + memcpy( &m.transAttr, transAttr, sizeof(TransactionAttributes) ); 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; + m.ttl = ttl; + m.sendFunc = sendFunc; + + m.sendFunc = sendFunc; + m.addSoftware = false; /* callback and data (owned by caller) */ m.stunCbFunc = stunCbFunc; m.stuntrace = true; m.addTransCnt = false; - StoreStunBindReq(&trans, &m); BuildStunBindReq(&trans, &stunMsg); StunClientMain(clientData, STUNCLIENT_CTX_UNKNOWN, STUN_SIGNAL_BindReq, @@ -428,7 +397,7 @@ StunClient_HandleIncResp(STUN_CLIENT_DATA* clientData, STUN_TRANSACTION_DATA* trans = &clientData->data[i]; if ( trans->inUse && stunlib_transIdIsEqual(&msg->msgHdr.id, - &trans->stunBindReq.transactionId) ) + &trans->stunBindReq.transAttr.transactionId) ) { StunRespStruct m; /* What timer to stop? */ @@ -478,8 +447,9 @@ StunClient_HandleICMP(STUN_CLIENT_DATA* clientData, { STUN_TRANSACTION_DATA* trans = &clientData->data[i]; if ( trans->inUse && - stunlib_transIdIsEqual(&clientData->traceResult.currStunMsgId, - &trans->stunBindReq.transactionId) ) + stunlib_transIdIsEqual(&clientData->traceResult.transAttr. + transactionId, + &trans->stunBindReq.transAttr.transactionId) ) { StunRespStruct m; gettimeofday(&trans->stop[trans->retransmits], NULL); @@ -524,7 +494,7 @@ StunClient_cancelBindingTransaction(STUN_CLIENT_DATA* clientData, STUN_TRANSACTION_DATA* trans = &clientData->data[i]; if ( trans->inUse && stunlib_transIdIsEqual(&transactionId, - &trans->stunBindReq.transactionId) ) + &trans->stunBindReq.transAttr.transactionId) ) { StunClientMain(clientData, i, STUN_SIGNAL_Cancel, NULL); return i; @@ -778,15 +748,15 @@ SendStunReq(STUN_TRANSACTION_DATA* trans, * request */ /* encode the BindReq */ - if (strlen(trans->stunBindReq.password) > 0) + if (strlen(trans->stunBindReq.transAttr.password) > 0) { stunReqMsgBufLen = stunlib_encodeMessage(stunReqMsg, (unsigned char*) (stunReqMsgBuf), STUN_MAX_PACKET_SIZE, - (unsigned char*)&trans->stunBindReq.password, + (unsigned char*)&trans->stunBindReq.transAttr.password, /* key */ strlen(trans->stunBindReq. - password), + transAttr.password), /* keyLen * */ NULL); @@ -819,7 +789,7 @@ SendStunReq(STUN_TRANSACTION_DATA* trans, if (trans->stunBindReq.sendFunc != NULL) { trans->stunBindReq.sendFunc(trans->client->userCtx, - trans->stunBindReq.sockhandle, + trans->stunBindReq.transAttr.sockhandle, stunReqMsgBuf, stunReqMsgBufLen, (struct sockaddr*)&trans->stunBindReq.serverAddr, @@ -870,15 +840,15 @@ RetransmitLastReq(STUN_TRANSACTION_DATA* trans, int stunReqMsgBufLen; /* of encoded STUN * request */ - if (strlen(trans->stunBindReq.password) > 0) + if (strlen(trans->stunBindReq.transAttr.password) > 0) { stunReqMsgBufLen = stunlib_encodeMessage(stunReqMsg, (unsigned char*) (stunReqMsgBuf), STUN_MAX_PACKET_SIZE, - (unsigned char*)&trans->stunBindReq.password, + (unsigned char*)&trans->stunBindReq.transAttr.password, /* key */ strlen(trans->stunBindReq. - password), + transAttr.password), /* keyLen * */ NULL); @@ -897,7 +867,7 @@ RetransmitLastReq(STUN_TRANSACTION_DATA* trans, } gettimeofday(&trans->start[trans->retransmits], NULL); trans->stunBindReq.sendFunc(trans->client->userCtx, - trans->stunBindReq.sockhandle, + trans->stunBindReq.transAttr.sockhandle, stunReqMsgBuf, stunReqMsgBufLen, (struct sockaddr*)destAddr, @@ -973,7 +943,8 @@ CallBack(STUN_TRANSACTION_DATA* trans, StunCallBackData_T res; memset( &res, 0, sizeof (StunCallBackData_T) ); - memcpy( &res.msgId, &trans->stunBindReq.transactionId, sizeof(StunMsgId) ); + memcpy( &res.msgId, &trans->stunBindReq.transAttr.transactionId, + sizeof(StunMsgId) ); res.stunResult = stunResult; res.ttl = trans->stunBindReq.ttl; res.rtt = getRTTvalue(trans); @@ -1126,7 +1097,8 @@ BindRespCallback(STUN_TRANSACTION_DATA* trans, memset( &res, 0, sizeof (StunCallBackData_T) ); - memcpy( &res.msgId, &trans->stunBindReq.transactionId, sizeof(StunMsgId) ); + memcpy( &res.msgId, &trans->stunBindReq.transAttr.transactionId, + sizeof(StunMsgId) ); res.stunResult = StunResult_BindOk; @@ -1172,7 +1144,8 @@ ICMPRespCallback(STUN_TRANSACTION_DATA* trans, memset( &res, 0, sizeof (StunCallBackData_T) ); - memcpy( &res.msgId, &trans->stunBindReq.transactionId, sizeof(StunMsgId) ); + memcpy( &res.msgId, &trans->stunBindReq.transAttr.transactionId, + sizeof(StunMsgId) ); res.stunResult = StunResult_ICMPResp; res.ICMPtype = trans->ICMPtype; diff --git a/src/stunlib.c b/src/stunlib.c index 2b6454a..39a01a6 100644 --- a/src/stunlib.c +++ b/src/stunlib.c @@ -872,19 +872,20 @@ stunEncodeEvenPort(StunAtrEvenPort* pEvenPort, } static bool -stunEncodeStreamType(StunAtrStreamType* pStreamType, - uint8_t** pBuf, - int* nBufLen) +stunEncodeEnfFlowDescription(StunAtrEnfFlowDescription* pStreamType, + uint8_t** pBuf, + int* nBufLen) { if (*nBufLen < 24) { return false; } - write_16(pBuf, STUN_ATTR_StreamType); /* Attr type */ - write_16(pBuf, 3); /* Length */ - write_16(pBuf, pStreamType->type); - write_8(pBuf, pStreamType->interactivity); + uint8_t typeAndTbd = pStreamType->type << 4; + write_16(pBuf, STUN_ATTR_EnfFlowDescription); /* Attr type */ + write_16(pBuf, 3); /* Length */ + write_8(pBuf, typeAndTbd); + write_16(pBuf, pStreamType->bandwidthMax); write_8(pBuf, pStreamType->pad); *nBufLen -= 8; return true; @@ -892,15 +893,15 @@ stunEncodeStreamType(StunAtrStreamType* pStreamType, static bool -stunEncodeNetworkStatus(StunAtrNetworkStatus* pNetworkStatus, - uint8_t** pBuf, - int* nBufLen) +stunEncodeEnfNetworkStatus(StunAtrEnfNetworkStatus* pNetworkStatus, + uint8_t** pBuf, + int* nBufLen) { if (*nBufLen < 32) { return false; } - write_16(pBuf, STUN_ATTR_NetworkStatus); /* Attr type */ + write_16(pBuf, STUN_ATTR_EnfNetworkStatus); /* Attr type */ write_16(pBuf, 8); /* Length */ write_8(pBuf, pNetworkStatus->flags); write_8(pBuf, pNetworkStatus->nodeCnt); @@ -950,7 +951,7 @@ stunEncodeTTL(StunAtrTTL* pTTL, return true; } - +#if 0 static bool stunEncodeCiscoNetworkFeedback(StunAtrCiscoNetworkFeedback* ciscoNetFeed, uint8_t** pBuf, @@ -970,10 +971,11 @@ stunEncodeCiscoNetworkFeedback(StunAtrCiscoNetworkFeedback* ciscoNetFeed, return true; } + static bool -stunEncodeBandwidthUsage(StunAtrBandwidthUsage* pBandwidthUsage, - uint8_t** pBuf, - int* nBufLen) +encodeStunAtrBandwidthUsage* pBandwidthUsage, + uint8_t** pBuf, +int* nBufLen) { if (*nBufLen < 4) { @@ -987,6 +989,7 @@ stunEncodeBandwidthUsage(StunAtrBandwidthUsage* pBandwidthUsage, *nBufLen -= 8; return true; } +#endif static uint32_t stunlib_EncodeIndication(uint8_t msgType, @@ -1507,30 +1510,30 @@ stunDecodeDataAtr(StunData* pData, return true; } + static bool -stunDecodeStreamType(StunAtrStreamType* streamTypeAtr, - const uint8_t** pBuf, - int* nBufLen) +stunDecodeEnfFlowDescription(StunAtrEnfFlowDescription* streamTypeAtr, + const uint8_t** pBuf, + int* nBufLen) { if (*nBufLen < 4) { return false; } - - - - - read_16(pBuf, &streamTypeAtr->type); - read_8(pBuf, &streamTypeAtr->interactivity); + uint8_t typeAndTbd; + read_8(pBuf, &typeAndTbd); + streamTypeAtr->type = typeAndTbd >> 4; + read_16(pBuf, &streamTypeAtr->bandwidthMax); read_8(pBuf, &streamTypeAtr->pad); *nBufLen -= 4; return true; } + static bool -stunDecodeNetworkStatus(StunAtrNetworkStatus* networkStatusAtr, - const uint8_t** pBuf, - int* nBufLen) +stunDecodeEnfNetworkStatus(StunAtrEnfNetworkStatus* networkStatusAtr, + const uint8_t** pBuf, + int* nBufLen) { if (*nBufLen < 4) { @@ -1543,7 +1546,6 @@ stunDecodeNetworkStatus(StunAtrNetworkStatus* networkStatusAtr, read_16(pBuf, &networkStatusAtr->upMaxBandwidth); read_16(pBuf, &networkStatusAtr->downMaxBandwidth); - *nBufLen -= 8; return true; } @@ -1566,42 +1568,6 @@ stunDecodeTransCount(StunAtrTransCount* transCountAtr, } - -static bool -stunDecodeCiscoNetworkFeedback(StunAtrCiscoNetworkFeedback* ciscoNetFeed, - const uint8_t** pBuf, - int* nBufLen) -{ - if (*nBufLen < 4) - { - return false; - } - - read_32(pBuf, &ciscoNetFeed->first); - read_32(pBuf, &ciscoNetFeed->second); - read_32(pBuf, &ciscoNetFeed->third); - - *nBufLen -= 12; - return true; -} - - -static bool -stunDecodeBandwidthUsage(StunAtrBandwidthUsage* bandwidthUsageAtr, - const uint8_t** pBuf, - int* nBufLen) -{ - if (*nBufLen < 1) - { - return false; - } - read_16(pBuf, &bandwidthUsageAtr->average); - read_16(pBuf, &bandwidthUsageAtr->max); - - *nBufLen -= 4; - return true; -} - static bool stunDecodeTTL(StunAtrTTL* ttl, const uint8_t** pBuf, @@ -2425,7 +2391,7 @@ stunlib_DecodeMessage(const uint8_t* buf, } message->hasTTL = true; break; - +#if 0 case STUN_ATTR_StreamType: if ( !stunDecodeStreamType(&message->streamType, &pCurrPtr, @@ -2435,17 +2401,18 @@ stunlib_DecodeMessage(const uint8_t* buf, } message->hasStreamType = true; break; - - case STUN_ATTR_BandwidthUsage: - if ( !stunDecodeBandwidthUsage(&message->bandwidthUsage, - &pCurrPtr, - &restlen) ) +#endif + case STUN_ATTR_EnfFlowDescription: + if ( !stunDecodeEnfFlowDescription(&message->enfFlowDescription, + &pCurrPtr, + &restlen) ) { return false; } - message->hasBandwidthUsage = true; + message->hasEnfFlowDescription = true; break; + case STUN_ATTR_TransCount: if ( !stunDecodeTransCount(&message->transCount, &pCurrPtr, @@ -2457,29 +2424,29 @@ stunlib_DecodeMessage(const uint8_t* buf, break; - case STUN_ATTR_NetworkStatus: + case STUN_ATTR_EnfNetworkStatus: if (message->hasMessageIntegrity) { - if ( !stunDecodeNetworkStatus(&message->networkStatus, - &pCurrPtr, - &restlen) ) + if ( !stunDecodeEnfNetworkStatus(&message->enfNetworkStatus, + &pCurrPtr, + &restlen) ) { return false; } - message->hasNetworkStatus = true; + message->hasEnfNetworkStatus = true; } else { - if ( !stunDecodeNetworkStatus(&message->networkStatusResp, - &pCurrPtr, - &restlen) ) + if ( !stunDecodeEnfNetworkStatus(&message->enfNetworkStatusResp, + &pCurrPtr, + &restlen) ) { return false; } - message->hasNetworkStatusResp = true; + message->hasEnfNetworkStatusResp = true; } break; - +#if 0 case STUN_ATTR_Cisco_Network_Feedback: if (message->hasMessageIntegrity) { @@ -2502,7 +2469,7 @@ stunlib_DecodeMessage(const uint8_t* buf, message->hasCiscoNetFeedResp = true; } break; - +#endif case STUN_ATTR_ICEControlling: if ( !stunDecodeDoubleValueAtr(&message->controlling, &pCurrPtr, @@ -3100,9 +3067,10 @@ stunlib_encodeMessage(StunMessage* message, } - if ( message->hasStreamType && !stunEncodeStreamType(&message->streamType, - &pCurrPtr, - &restlen) ) + if ( message->hasEnfFlowDescription && + !stunEncodeEnfFlowDescription(&message->enfFlowDescription, + &pCurrPtr, + &restlen) ) { if (stream) { @@ -3111,20 +3079,6 @@ stunlib_encodeMessage(StunMessage* message, return 0; } - - if ( message->hasBandwidthUsage && - !stunEncodeBandwidthUsage(&message->bandwidthUsage, - &pCurrPtr, - &restlen) ) - { - if (stream) - { - printError(stream, "Invalid BandwidthUsage attribute\n"); - } - return 0; - } - - if ( message->hasTTL && !stunEncodeTTL(&message->ttl, &pCurrPtr, &restlen) ) @@ -3136,10 +3090,10 @@ stunlib_encodeMessage(StunMessage* message, return 0; } - if ( message->hasNetworkStatusResp && - !stunEncodeNetworkStatus(&message->networkStatusResp, - &pCurrPtr, - &restlen) ) + if ( message->hasEnfNetworkStatusResp && + !stunEncodeEnfNetworkStatus(&message->enfNetworkStatusResp, + &pCurrPtr, + &restlen) ) { if (stream) { @@ -3148,18 +3102,6 @@ stunlib_encodeMessage(StunMessage* message, return 0; } - if ( message->hasCiscoNetFeedResp && - !stunEncodeCiscoNetworkFeedback(&message->ciscoNetFeedResp, - &pCurrPtr, - &restlen) ) - { - if (stream) - { - printError(stream, "Invalid Cisco Network Feedback attribute\n"); - } - return 0; - } - if ( message->hasTransCount && !stunEncodeTransCount(&message->transCount, &pCurrPtr, @@ -3204,12 +3146,12 @@ stunlib_encodeMessage(StunMessage* message, } - /*DISCUSS NETWORK-STATUS Attribute is to be placed after integrity attribute*/ + /*ENF NETWORK-STATUS Attribute is to be placed after integrity attribute*/ - if ( message->hasNetworkStatus && - !stunEncodeNetworkStatus(&message->networkStatus, - &pCurrPtr, - &restlen) ) + if ( message->hasEnfNetworkStatus && + !stunEncodeEnfNetworkStatus(&message->enfNetworkStatus, + &pCurrPtr, + &restlen) ) { if (stream) { @@ -3218,20 +3160,6 @@ stunlib_encodeMessage(StunMessage* message, return 0; } - if ( message->hasCiscoNetFeed && - !stunEncodeCiscoNetworkFeedback(&message->ciscoNetFeed, - &pCurrPtr, - &restlen) ) - { - if (stream) - { - printError(stream, "Invalid Cisco Network Feedback attribute\n"); - } - return 0; - } - - - msglen = bufLen - restlen; message->msgHdr.msgLength = msglen - STUN_HEADER_SIZE; pCurrPtr = (uint8_t*)buf; diff --git a/src/stunserver.c b/src/stunserver.c index f92c3f6..73632da 100644 --- a/src/stunserver.c +++ b/src/stunserver.c @@ -12,9 +12,12 @@ CreateConnectivityBindingResp(StunMessage* stunMsg, const struct sockaddr* mappedSockAddr, uint8_t reqTrnspCnt, uint8_t respTrnspCnt, + uint8_t enf_flags, + uint8_t enf_nodeCnt, + uint16_t enf_upMaxBandwidth, + uint16_t enf_downMaxBandwidth, uint16_t response, - uint32_t responseCode, - DiscussData* discussData) + uint32_t responseCode) { StunIPAddress mappedAddr; @@ -65,28 +68,20 @@ CreateConnectivityBindingResp(StunMessage* stunMsg, stunMsg->hasXorMappedAddress = true; stunMsg->xorMappedAddress = mappedAddr; - if (discussData != NULL) + + /* ENF */ + if (enf_nodeCnt > 0) { - stunMsg->hasStreamType = true; - stunMsg->streamType.type = discussData->streamType; - stunMsg->streamType.interactivity = discussData->interactivity; - - stunMsg->hasNetworkStatus = true; - stunMsg->networkStatus.flags = 0; - stunMsg->networkStatus.nodeCnt = 0; - stunMsg->networkStatus.upMaxBandwidth = 0; - stunMsg->networkStatus.downMaxBandwidth = 0; - - stunMsg->hasNetworkStatusResp = true; - stunMsg->networkStatusResp.flags = - discussData->networkStatusResp_flags; - stunMsg->networkStatusResp.nodeCnt = - discussData->networkStatusResp_nodeCnt; - stunMsg->networkStatusResp.upMaxBandwidth = - discussData->networkStatusResp_upMaxBandwidth; - stunMsg->networkStatusResp.downMaxBandwidth = - discussData->networkStatusResp_downMaxBandwidth; + stunMsg->hasEnfNetworkStatus = true; + memset( &stunMsg->enfNetworkStatus, 0,sizeof(StunAtrEnfNetworkStatus) ); + stunMsg->hasEnfNetworkStatusResp = true; + stunMsg->enfNetworkStatusResp.flags = enf_flags; + stunMsg->enfNetworkStatusResp.nodeCnt = enf_nodeCnt; + stunMsg->enfNetworkStatusResp.tbd = 0; + stunMsg->enfNetworkStatusResp.upMaxBandwidth = enf_upMaxBandwidth; + stunMsg->enfNetworkStatusResp.downMaxBandwidth = enf_downMaxBandwidth; } + if (responseCode != 200) { stunMsg->hasErrorCode = true; @@ -168,12 +163,15 @@ StunServer_SendConnectivityBindingResp(STUN_CLIENT_DATA* clientData, const struct sockaddr* dstAddr, uint8_t reqTrnspCnt, uint8_t respTrnspCnt, + uint8_t enf_flags, + uint8_t enf_nodeCnt, + uint16_t enf_upMaxBandwidth, + uint16_t enf_downMaxBandwidth, void* userData, STUN_SENDFUNC sendFunc, int proto, bool useRelay, - uint32_t responseCode, - DiscussData* discussData) + uint32_t responseCode) { StunMessage stunRespMsg; @@ -183,11 +181,14 @@ StunServer_SendConnectivityBindingResp(STUN_CLIENT_DATA* clientData, mappedAddr, reqTrnspCnt, respTrnspCnt, + enf_flags, + enf_nodeCnt, + enf_upMaxBandwidth, + enf_downMaxBandwidth, (responseCode == 200) ? STUN_MSG_BindResponseMsg : STUN_MSG_BindErrorResponseMsg, - responseCode, - discussData) ) + responseCode) ) { /* encode and send */ if ( SendConnectivityBindResponse(clientData, diff --git a/src/stuntrace.c b/src/stuntrace.c index 45ccadc..40f002e 100644 --- a/src/stuntrace.c +++ b/src/stuntrace.c @@ -76,14 +76,10 @@ resartIfNotDone(struct hiutResult* result) (struct sockaddr*)&result->remoteAddr, (struct sockaddr*)&result->localAddr, false, - result->username, - result->password, result->currentTTL, - result->currStunMsgId, - result->sockfd, + &result->transAttr, result->sendFunc, - StunStatusCallBack, - NULL ); + StunStatusCallBack ); } } @@ -124,21 +120,18 @@ handleStunNoAnswer(struct hiutResult* result) result->remoteAlive = false; result->currentTTL = 1; - stunlib_createId(&result->currStunMsgId); + stunlib_createId(&result->transAttr.transactionId); StunClient_startSTUNTrace( (STUN_CLIENT_DATA*)result->stunCtx, result, (struct sockaddr*)&result->remoteAddr, (struct sockaddr*)&result->localAddr, false, - result->username, - result->password, result->currentTTL, - result->currStunMsgId, - result->sockfd, + &result->transAttr, result->sendFunc, - StunStatusCallBack, - NULL ); + StunStatusCallBack ); + return; } /* Hov many no answer in a row? */ @@ -173,21 +166,17 @@ handleStunNoAnswer(struct hiutResult* result) { result->currentTTL++; } - stunlib_createId(&result->currStunMsgId); + stunlib_createId(&result->transAttr.transactionId); StunClient_startSTUNTrace( (STUN_CLIENT_DATA*)result->stunCtx, result, (struct sockaddr*)&result->remoteAddr, (struct sockaddr*)&result->localAddr, false, - result->username, - result->password, result->currentTTL, - result->currStunMsgId, - result->sockfd, + &result->transAttr, result->sendFunc, - StunStatusCallBack, - NULL ); + StunStatusCallBack ); } } @@ -206,21 +195,17 @@ handleStunRespIcmp(struct hiutResult* result, result->remoteAlive = true; result->currentTTL = 1; - stunlib_createId(&result->currStunMsgId); + stunlib_createId(&result->transAttr.transactionId); StunClient_startSTUNTrace( (STUN_CLIENT_DATA*)result->stunCtx, result, (struct sockaddr*)&result->remoteAddr, (struct sockaddr*)&result->localAddr, false, - result->username, - result->password, result->currentTTL, - result->currStunMsgId, - result->sockfd, + &result->transAttr, result->sendFunc, - StunStatusCallBack, - NULL ); + StunStatusCallBack ); return; } if ( isTimeExceeded(ICMPtype, srcAddr->sa_family) ) @@ -243,21 +228,17 @@ handleStunRespIcmp(struct hiutResult* result, false, false); - stunlib_createId(&result->currStunMsgId); + stunlib_createId(&result->transAttr.transactionId); StunClient_startSTUNTrace( (STUN_CLIENT_DATA*)result->stunCtx, result, (struct sockaddr*)&result->remoteAddr, (struct sockaddr*)&result->localAddr, false, - result->username, - result->password, result->currentTTL, - result->currStunMsgId, - result->sockfd, + &result->transAttr, result->sendFunc, - StunStatusCallBack, - NULL ); + StunStatusCallBack ); return; } } @@ -309,21 +290,17 @@ handleStunRespSucsessfull(struct hiutResult* result, result->remoteAlive = true; result->currentTTL = 1; - stunlib_createId(&result->currStunMsgId); + stunlib_createId(&result->transAttr.transactionId); StunClient_startSTUNTrace( (STUN_CLIENT_DATA*)result->stunCtx, result, (struct sockaddr*)&result->remoteAddr, (struct sockaddr*)&result->localAddr, false, - result->username, - result->password, result->currentTTL, - result->currStunMsgId, - result->sockfd, + &result->transAttr, result->sendFunc, - StunStatusCallBack, - NULL ); + StunStatusCallBack ); return; } @@ -412,7 +389,7 @@ StunTrace_startTrace(STUN_CLIENT_DATA* clientData, result->currentTTL = MAX_TTL; result->userCtx = userCtx; - stunlib_createId(&result->currStunMsgId); + stunlib_createId(&result->transAttr.transactionId); 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!! */ @@ -430,24 +407,22 @@ StunTrace_startTrace(STUN_CLIENT_DATA* clientData, result->num_traces = 1; result->traceCb = traceCbFunc; result->sendFunc = sendFunc; - result->sockfd = sockhandle; + result->transAttr.sockhandle = sockhandle; - strncpy(result->username, ufrag, sizeof(result->username) - 1); - strncpy(result->password, password, sizeof(result->password) - 1); + strncpy(result->transAttr.username, ufrag, + sizeof(result->transAttr.username) - 1); + strncpy(result->transAttr.password, password, + sizeof(result->transAttr.password) - 1); StunClient_startSTUNTrace(result->stunCtx, result, toAddr, fromAddr, false, - result->username, - result->password, result->currentTTL, - result->currStunMsgId, - result->sockfd, + &result->transAttr, result->sendFunc, - StunStatusCallBack, - NULL); + StunStatusCallBack); return 1; } diff --git a/test/ctest.h b/test/ctest.h index 75fda66..2a585c7 100644 --- a/test/ctest.h +++ b/test/ctest.h @@ -17,83 +17,88 @@ #define CTEST_H #ifndef UNUSED_PARAM - /** - * \def UNUSED_PARAM(p); - * - * A macro for quelling compiler warnings about unused variables. - */ -# define UNUSED_PARAM(p) ((void)&(p)) +/** + * \def UNUSED_PARAM(p); + * + * A macro for quelling compiler warnings about unused variables. + */ +# define UNUSED_PARAM(p) ( (void)&(p) ) #endif /* UNUSED_PARM */ -typedef void (*SetupFunc)(void*); -typedef void (*TearDownFunc)(void*); +typedef void (* SetupFunc)(void*); +typedef void (* TearDownFunc)(void*); struct ctest { - const char* ssname; // suite name - const char* ttname; // test name - void (*run)(); - int skip; + const char* ssname; /* suite name */ + const char* ttname; /* test name */ + void (* run)(); + int skip; - void* data; - SetupFunc setup; - TearDownFunc teardown; + void* data; + SetupFunc setup; + TearDownFunc teardown; - unsigned int magic; + unsigned int magic; }; -#define __FNAME(sname, tname) __ctest_##sname##_##tname##_run -#define __TNAME(sname, tname) __ctest_##sname##_##tname +#define __FNAME(sname, tname) __ctest_ ## sname ## _ ## tname ## _run +#define __TNAME(sname, tname) __ctest_ ## sname ## _ ## tname #define __CTEST_MAGIC (0xdeadbeef) #ifdef __APPLE__ -#define __Test_Section __attribute__ ((unused,section ("__DATA, .ctest"))) +#define __Test_Section __attribute__ ( ( unused,section("__DATA, .ctest") ) ) #else -#define __Test_Section __attribute__ ((unused,section (".ctest"))) +#define __Test_Section __attribute__ ( ( unused,section(".ctest") ) ) #endif #define __CTEST_STRUCT(sname, tname, _skip, __data, __setup, __teardown) \ - struct ctest __TNAME(sname, tname) __Test_Section = { \ - .ssname=#sname, \ - .ttname=#tname, \ - .run = __FNAME(sname, tname), \ - .skip = _skip, \ - .data = __data, \ - .setup = (SetupFunc)__setup, \ - .teardown = (TearDownFunc)__teardown, \ - .magic = __CTEST_MAGIC }; - -#define CTEST_DATA(sname) struct sname##_data + struct ctest __TNAME(sname, tname) __Test_Section = { \ + .ssname =#sname, \ + .ttname =#tname, \ + .run = __FNAME(sname, tname), \ + .skip = _skip, \ + .data = __data, \ + .setup = (SetupFunc)__setup, \ + .teardown = (TearDownFunc)__teardown, \ + .magic = __CTEST_MAGIC }; + +#define CTEST_DATA(sname) struct sname ## _data #define CTEST_SETUP(sname) \ - void __attribute__ ((weak)) sname##_setup(struct sname##_data* data) + void __attribute__ ( (weak) ) sname ## _setup(struct sname ## _data* data) #define CTEST_TEARDOWN(sname) \ - void __attribute__ ((weak)) sname##_teardown(struct sname##_data* data) + void __attribute__ ( (weak) ) sname ## _teardown(struct sname ## _data* data) #define __CTEST_INTERNAL(sname, tname, _skip) \ - void __FNAME(sname, tname)(); \ - __CTEST_STRUCT(sname, tname, _skip, NULL, NULL, NULL) \ - void __FNAME(sname, tname)() + void __FNAME(sname, tname)(); \ + __CTEST_STRUCT(sname, tname, _skip, NULL, NULL, NULL) \ + void __FNAME(sname, tname)() #ifdef __APPLE__ #define SETUP_FNAME(sname) NULL #define TEARDOWN_FNAME(sname) NULL #else -#define SETUP_FNAME(sname) sname##_setup -#define TEARDOWN_FNAME(sname) sname##_teardown +#define SETUP_FNAME(sname) sname ## _setup +#define TEARDOWN_FNAME(sname) sname ## _teardown #endif #define __CTEST2_INTERNAL(sname, tname, _skip) \ - static struct sname##_data __ctest_##sname##_data; \ - CTEST_SETUP(sname); \ - CTEST_TEARDOWN(sname); \ - void __FNAME(sname, tname)(struct sname##_data* data); \ - __CTEST_STRUCT(sname, tname, _skip, &__ctest_##sname##_data, SETUP_FNAME(sname), TEARDOWN_FNAME(sname)) \ - void __FNAME(sname, tname)(struct sname##_data* data) - - -void CTEST_LOG(char *fmt, ...); -void CTEST_ERR(char *fmt, ...); // doesn't return + static struct sname ## _data __ctest_ ## sname ## _data; \ + CTEST_SETUP(sname); \ + CTEST_TEARDOWN(sname); \ + void __FNAME(sname, tname)(struct sname ## _data* data); \ + __CTEST_STRUCT( sname, tname, _skip, &__ctest_ ## sname ## _data, \ + SETUP_FNAME(sname), TEARDOWN_FNAME(sname) ) \ + void __FNAME(sname, tname)(struct sname ## _data* data) + + +void +CTEST_LOG(char* fmt, + ...); +void +CTEST_ERR(char* fmt, + ...); /* doesn't return */ #define CTEST(sname, tname) __CTEST_INTERNAL(sname, tname, 0) #define CTEST_SKIP(sname, tname) __CTEST_INTERNAL(sname, tname, 1) @@ -102,34 +107,67 @@ void CTEST_ERR(char *fmt, ...); // doesn't return #define CTEST2_SKIP(sname, tname) __CTEST2_INTERNAL(sname, tname, 1) -void assert_str(const char* exp, const char* real, const char* caller, int line); +void +assert_str(const char* exp, + const char* real, + const char* caller, + int line); #define ASSERT_STR(exp, real) assert_str(exp, real, __FILE__, __LINE__) -void assert_data(const unsigned char* exp, int expsize, - const unsigned char* real, int realsize, - const char* caller, int line); +void +assert_data(const unsigned char* exp, + int expsize, + const unsigned char* real, + int realsize, + const char* caller, + int line); #define ASSERT_DATA(exp, expsize, real, realsize) \ - assert_data(exp, expsize, real, realsize, __FILE__, __LINE__) + assert_data(exp, expsize, real, realsize, __FILE__, __LINE__) -void assert_equal(long exp, long real, const char* caller, int line); +void +assert_equal(long exp, + long real, + const char* caller, + int line); #define ASSERT_EQUAL(exp, real) assert_equal(exp, real, __FILE__, __LINE__) -void assert_not_equal(long exp, long real, const char* caller, int line); -#define ASSERT_NOT_EQUAL(exp, real) assert_not_equal(exp, real, __FILE__, __LINE__) - -void assert_null(void* real, const char* caller, int line); -#define ASSERT_NULL(real) assert_null((void*)real, __FILE__, __LINE__) - -void assert_not_null(const void* real, const char* caller, int line); +void +assert_not_equal(long exp, + long real, + const char* caller, + int line); +#define ASSERT_NOT_EQUAL(exp, real) assert_not_equal(exp, \ + real, \ + __FILE__, \ + __LINE__) + +void +assert_null(void* real, + const char* caller, + int line); +#define ASSERT_NULL(real) assert_null( (void*)real, __FILE__, __LINE__ ) + +void +assert_not_null(const void* real, + const char* caller, + int line); #define ASSERT_NOT_NULL(real) assert_not_null(real, __FILE__, __LINE__) -void assert_true(int real, const char* caller, int line); +void +assert_true(int real, + const char* caller, + int line); #define ASSERT_TRUE(real) assert_true(real, __FILE__, __LINE__) -void assert_false(int real, const char* caller, int line); +void +assert_false(int real, + const char* caller, + int line); #define ASSERT_FALSE(real) assert_false(real, __FILE__, __LINE__) -void assert_fail(const char* caller, int line); +void +assert_fail(const char* caller, + int line); #define ASSERT_FAIL() assert_fail(__FILE__, __LINE__) #ifdef CTEST_MAIN @@ -148,17 +186,17 @@ void assert_fail(const char* caller, int line); #include #endif -//#define COLOR_OK +/* #define COLOR_OK */ static size_t ctest_errorsize; -static char* ctest_errormsg; +static char* ctest_errormsg; #define MSG_SIZE 4096 -static char ctest_errorbuffer[MSG_SIZE]; -static jmp_buf ctest_err; -static int color_output = 1; +static char ctest_errorbuffer[MSG_SIZE]; +static jmp_buf ctest_err; +static int color_output = 1; static const char* suite_name; -typedef int (*filter_func)(struct ctest*); +typedef int (* filter_func)(struct ctest*); #define ANSI_BLACK "\033[0;30m" #define ANSI_RED "\033[0;31m" @@ -178,280 +216,412 @@ typedef int (*filter_func)(struct ctest*); #define ANSI_WHITE "\033[01;37m" #define ANSI_NORMAL "\033[0m" -static CTEST(suite, test) { } +static CTEST(suite, test) { +} -static void msg_start(const char* color, const char* title) { - int size; - if (color_output) { - size = snprintf(ctest_errormsg, ctest_errorsize, "%s", color); - ctest_errorsize -= size; - ctest_errormsg += size; - } - size = snprintf(ctest_errormsg, ctest_errorsize, " %s: ", title); +static void +msg_start(const char* color, + const char* title) +{ + int size; + if (color_output) + { + size = snprintf(ctest_errormsg, ctest_errorsize, "%s", color); ctest_errorsize -= size; - ctest_errormsg += size; + ctest_errormsg += size; + } + size = snprintf(ctest_errormsg, ctest_errorsize, " %s: ", title); + ctest_errorsize -= size; + ctest_errormsg += size; } -static void msg_end() { - int size; - if (color_output) { - size = snprintf(ctest_errormsg, ctest_errorsize, ANSI_NORMAL); - ctest_errorsize -= size; - ctest_errormsg += size; - } - size = snprintf(ctest_errormsg, ctest_errorsize, "\n"); +static void +msg_end() +{ + int size; + if (color_output) + { + size = snprintf(ctest_errormsg, ctest_errorsize, ANSI_NORMAL); ctest_errorsize -= size; - ctest_errormsg += size; + ctest_errormsg += size; + } + size = snprintf(ctest_errormsg, ctest_errorsize, "\n"); + ctest_errorsize -= size; + ctest_errormsg += size; } -void CTEST_LOG(char *fmt, ...) +void +CTEST_LOG(char* fmt, + ...) { - va_list argp; - msg_start(ANSI_BLUE, "LOG"); + va_list argp; + msg_start(ANSI_BLUE, "LOG"); - va_start(argp, fmt); - int size = vsnprintf(ctest_errormsg, ctest_errorsize, fmt, argp); - ctest_errorsize -= size; - ctest_errormsg += size; - va_end(argp); + va_start(argp, fmt); + int size = vsnprintf(ctest_errormsg, ctest_errorsize, fmt, argp); + ctest_errorsize -= size; + ctest_errormsg += size; + va_end(argp); - msg_end(); + msg_end(); } -void CTEST_ERR(char *fmt, ...) +void +CTEST_ERR(char* fmt, + ...) { - va_list argp; - msg_start(ANSI_YELLOW, "ERR"); + va_list argp; + msg_start(ANSI_YELLOW, "ERR"); - va_start(argp, fmt); - int size = vsnprintf(ctest_errormsg, ctest_errorsize, fmt, argp); - ctest_errorsize -= size; - ctest_errormsg += size; - va_end(argp); + va_start(argp, fmt); + int size = vsnprintf(ctest_errormsg, ctest_errorsize, fmt, argp); + ctest_errorsize -= size; + ctest_errormsg += size; + va_end(argp); - msg_end(); - longjmp(ctest_err, 1); + msg_end(); + longjmp(ctest_err, 1); } -void assert_str(const char* exp, const char* real, const char* caller, int line) { - if ((exp == NULL && real != NULL) || - (exp != NULL && real == NULL) || - (exp && real && strcmp(exp, real) != 0)) { - CTEST_ERR("%s:%d expected '%s', got '%s'", caller, line, exp, real); - } +void +assert_str(const char* exp, + const char* real, + const char* caller, + int line) +{ + if ( ( (exp == NULL) && (real != NULL) ) || + ( (exp != NULL) && (real == NULL) ) || + ( exp && real && (strcmp(exp, real) != 0) ) ) + { + CTEST_ERR("%s:%d expected '%s', got '%s'", caller, line, exp, real); + } } -void assert_data(const unsigned char* exp, int expsize, - const unsigned char* real, int realsize, - const char* caller, int line) { - int i; - if (expsize != realsize) { - CTEST_ERR("%s:%d expected %d bytes, got %d", caller, line, expsize, realsize); - } - for (i=0; issname, strlen(suite_name)) == 0; +static int +suite_filter(struct ctest* t) +{ + return strncmp( suite_name, t->ssname, strlen(suite_name) ) == 0; } -static uint64_t getCurrentTime() { - struct timeval now; - gettimeofday(&now, NULL); - uint64_t now64 = now.tv_sec; - now64 *= 1000000; - now64 += (now.tv_usec); - return now64; +static uint64_t +getCurrentTime() +{ + struct timeval now; + gettimeofday(&now, NULL); + uint64_t now64 = now.tv_sec; + now64 *= 1000000; + now64 += (now.tv_usec); + return now64; } -static void color_print(const char* color, const char* text) { - if (color_output) - printf("%s%s"ANSI_NORMAL"\n", color, text); - else - printf("%s\n", text); +static void +color_print(const char* color, + const char* text) +{ + if (color_output) + { + printf("%s%s"ANSI_NORMAL "\n", color, text); + } + else + { + printf("%s\n", text); + } } #ifdef __APPLE__ -static void *find_symbol(struct ctest *test, const char *fname) +static void* +find_symbol(struct ctest* test, + const char* fname) { - size_t len = strlen(test->ssname) + 1 + strlen(fname); - char *symbol_name = (char *) malloc(len + 1); - memset(symbol_name, 0, len + 1); - snprintf(symbol_name, len + 1, "%s_%s", test->ssname, fname); - - //fprintf(stderr, ">>>> dlsym: loading %s\n", symbol_name); - void *symbol = dlsym(RTLD_DEFAULT, symbol_name); - if (!symbol) { - //fprintf(stderr, ">>>> ERROR: %s\n", dlerror()); - } - // returns NULL on error - - free(symbol_name); - return symbol; + size_t len = strlen(test->ssname) + 1 + strlen(fname); + char* symbol_name = (char*) malloc(len + 1); + memset(symbol_name, 0, len + 1); + snprintf(symbol_name, len + 1, "%s_%s", test->ssname, fname); + + /* fprintf(stderr, ">>>> dlsym: loading %s\n", symbol_name); */ + void* symbol = dlsym(RTLD_DEFAULT, symbol_name); + if (!symbol) + { + /* fprintf(stderr, ">>>> ERROR: %s\n", dlerror()); */ + } + /* returns NULL on error */ + + free(symbol_name); + return symbol; } #endif #ifdef CTEST_SEGFAULT #include -static void sighandler(int signum) +static void +sighandler(int signum) { - char msg[128]; - sprintf(msg, "[SIGNAL %d: %s]", signum, sys_siglist[signum]); - color_print(ANSI_BRED, msg); - fflush(stdout); - - /* "Unregister" the signal handler and send the signal back to the process - * so it can terminate as expected */ - signal(signum, SIG_DFL); - kill(getpid(), signum); + char msg[128]; + sprintf(msg, "[SIGNAL %d: %s]", signum, sys_siglist[signum]); + color_print(ANSI_BRED, msg); + fflush(stdout); + + /* "Unregister" the signal handler and send the signal back to the process + * so it can terminate as expected */ + signal(signum, SIG_DFL); + kill(getpid(), signum); } #endif -int ctest_main(int argc, const char *argv[]) +int +ctest_main(int argc, + const char* argv[]) { - static int total = 0; - static int num_ok = 0; - static int num_fail = 0; - static int num_skip = 0; - static int index = 1; - static filter_func filter = suite_all; + static int total = 0; + static int num_ok = 0; + static int num_fail = 0; + static int num_skip = 0; + static int index = 1; + static filter_func filter = suite_all; #ifdef CTEST_SEGFAULT - signal(SIGSEGV, sighandler); + signal(SIGSEGV, sighandler); #endif - if (argc == 2) { - suite_name = argv[1]; - filter = suite_filter; + if (argc == 2) + { + suite_name = argv[1]; + filter = suite_filter; + } + + color_output = isatty(1); + uint64_t t1 = getCurrentTime(); + + struct ctest* ctest_begin = &__TNAME(suite, test); + struct ctest* ctest_end = &__TNAME(suite, test); + /* find begin and end of section by comparing magics */ + while (1) + { + struct ctest* t = ctest_begin - 1; + if (t->magic != __CTEST_MAGIC) + { + break; } - - color_output = isatty(1); - uint64_t t1 = getCurrentTime(); - - struct ctest* ctest_begin = &__TNAME(suite, test); - struct ctest* ctest_end = &__TNAME(suite, test); - // find begin and end of section by comparing magics - while (1) { - struct ctest* t = ctest_begin-1; - if (t->magic != __CTEST_MAGIC) break; - ctest_begin--; + ctest_begin--; + } + while (1) + { + struct ctest* t = ctest_end + 1; + if (t->magic != __CTEST_MAGIC) + { + break; } - while (1) { - struct ctest* t = ctest_end+1; - if (t->magic != __CTEST_MAGIC) break; - ctest_end++; + ctest_end++; + } + ctest_end++; /* end after last one */ + + static struct ctest* test; + for (test = ctest_begin; test != ctest_end; test++) + { + if (test == &__ctest_suite_test) + { + continue; } - ctest_end++; // end after last one - - static struct ctest* test; - for (test = ctest_begin; test != ctest_end; test++) { - if (test == &__ctest_suite_test) continue; - if (filter(test)) total++; + if ( filter(test) ) + { + total++; } + } - for (test = ctest_begin; test != ctest_end; test++) { - if (test == &__ctest_suite_test) continue; - if (filter(test)) { - ctest_errorbuffer[0] = 0; - ctest_errorsize = MSG_SIZE-1; - ctest_errormsg = ctest_errorbuffer; - printf("TEST %d/%d %s:%s ", index, total, test->ssname, test->ttname); - fflush(stdout); - if (test->skip) { - color_print(ANSI_BYELLOW, "[SKIPPED]"); - num_skip++; - } else { - int result = setjmp(ctest_err); - if (result == 0) { + for (test = ctest_begin; test != ctest_end; test++) + { + if (test == &__ctest_suite_test) + { + continue; + } + if ( filter(test) ) + { + ctest_errorbuffer[0] = 0; + ctest_errorsize = MSG_SIZE - 1; + ctest_errormsg = ctest_errorbuffer; + printf("TEST %d/%d %s:%s ", index, total, test->ssname, test->ttname); + fflush(stdout); + if (test->skip) + { + color_print(ANSI_BYELLOW, "[SKIPPED]"); + num_skip++; + } + else + { + int result = setjmp(ctest_err); + if (result == 0) + { #ifdef __APPLE__ - if (!test->setup) { - test->setup = (SetupFunc)find_symbol(test, "setup"); - } - if (!test->teardown) { - test->teardown = (SetupFunc)find_symbol(test, "teardown"); - } + if (!test->setup) + { + test->setup = (SetupFunc)find_symbol(test, "setup"); + } + if (!test->teardown) + { + test->teardown = (SetupFunc)find_symbol(test, "teardown"); + } #endif - if (test->setup) test->setup(test->data); - if (test->data) - test->run(test->data); - else - test->run(); - if (test->teardown) test->teardown(test->data); - // if we got here it's ok + if (test->setup) + { + test->setup(test->data); + } + if (test->data) + { + test->run(test->data); + } + else + { + test->run(); + } + if (test->teardown) + { + test->teardown(test->data); + } + /* if we got here it's ok */ #ifdef COLOR_OK - color_print(ANSI_BGREEN, "[OK]"); + color_print(ANSI_BGREEN, "[OK]"); #else - printf("[OK]\n"); + printf("[OK]\n"); #endif - num_ok++; - } else { - color_print(ANSI_BRED, "[FAIL]"); - num_fail++; - } - if (ctest_errorsize != MSG_SIZE-1) printf("%s", ctest_errorbuffer); - } - index++; + num_ok++; + } + else + { + color_print(ANSI_BRED, "[FAIL]"); + num_fail++; } + if (ctest_errorsize != MSG_SIZE - 1) + { + printf("%s", ctest_errorbuffer); + } + } + index++; } - uint64_t t2 = getCurrentTime(); - - const char* color = (num_fail) ? ANSI_BRED : ANSI_GREEN; - char results[80]; - sprintf(results, "RESULTS: %d tests (%d ok, %d failed, %d skipped) ran in %"PRIu64" ms", total, num_ok, num_fail, num_skip, (t2 - t1)/1000); - color_print(color, results); - return num_fail; + } + uint64_t t2 = getCurrentTime(); + + const char* color = (num_fail) ? ANSI_BRED : ANSI_GREEN; + char results[80]; + sprintf(results, + "RESULTS: %d tests (%d ok, %d failed, %d skipped) ran in %" PRIu64 " ms", + total, + num_ok, + num_fail, + num_skip, + (t2 - t1) / 1000); + color_print(color, results); + return num_fail; } #endif diff --git a/test/stunclient_test.c b/test/stunclient_test.c index 04960d6..2641af4 100644 --- a/test/stunclient_test.c +++ b/test/stunclient_test.c @@ -40,7 +40,6 @@ static bool runningAsIPv6; StunResult_T stunResult; STUN_CLIENT_DATA* stunInstance; struct sockaddr_storage stunServerAddr; -DiscussData discussData; char logStr[200]; @@ -50,6 +49,9 @@ int lastTranspRespCnt; int lastTranspReqCnt; int lastRTT; +uint8_t lastEnfFlowType; +uint16_t lastEnfFlowMaxBw; + CTEST_DATA(data) { int a; @@ -62,10 +64,10 @@ StunStatusCallBack(void* ctx, StunCallBackData_T* retData) { (void)ctx; - stunResult = retData->stunResult; + stunResult = retData->stunResult; lastTranspRespCnt = retData->respTransCnt; - lastTranspReqCnt = retData->reqTransCnt; - lastRTT = retData->rtt; + lastTranspReqCnt = retData->reqTransCnt; + lastRTT = retData->rtt; /* printf("Got STUN status callback\n");// (Result (%i)\n", * retData->stunResult); */ } @@ -107,14 +109,20 @@ SendRawStun(void* ctx, sockaddr_toString(addr, addr_str, SOCKADDR_MAX_STRLEN, true); - // And then we deencode to chek if correct values are set.. + /* And then we deencode to chek if correct values are set.. */ StunMessage stunMsg; stunlib_DecodeMessage(buf, len, &stunMsg, NULL, - NULL); + NULL); lastReqCnt = 0; - if(stunMsg.hasTransCount){ + if (stunMsg.hasTransCount) + { lastReqCnt = stunMsg.transCount.reqCnt; - //lastTranspRespCnt = stunMsg.transCount.respCnt; + /* lastTranspRespCnt = stunMsg.transCount.respCnt; */ + } + if (stunMsg.hasEnfFlowDescription) + { + lastEnfFlowType = stunMsg.enfFlowDescription.type; + lastEnfFlowMaxBw = stunMsg.enfFlowDescription.bandwidthMax; } /* printf("Sendto: '%s'\n", addr_str); */ @@ -128,7 +136,7 @@ stundbg(void* ctx, (void) category; (void) ctx; strncpy(logStr, errStr, sizeof logStr); - //printf("%s\n", errStr); + /* printf("%s\n", errStr); */ } static int @@ -139,6 +147,16 @@ StartBindTransaction(int n) CurrAppCtx.a = AppCtx[n].a = 100 + n; CurrAppCtx.b = AppCtx[n].b = 200 + n; + TransactionAttributes transAttr; + + transAttr.transactionId = LastTransId; + transAttr.sockhandle = 0; + strncpy(transAttr.username, "pem", 4); + strncpy(transAttr.password, "pem", 4); + transAttr.peerPriority = 34567; + transAttr.useCandidate = false; + transAttr.iceControlling = false; + transAttr.tieBreaker = 4567; /* kick off stun */ return StunClient_startBindTransaction(stunInstance, @@ -147,45 +165,33 @@ StartBindTransaction(int n) NULL, 0, false, - "pem", - "pem", - 34567, /* uint32_t - * 1845494271 - * (priority) */ - false, - false, - 4567, /* uint64_t - * - * - * - *0x932FF9B151263B36LL - * (tieBreaker) */ - LastTransId, - 0, /* socket */ - SendRawStun, /* send func */ - StunStatusCallBack, - NULL); + &transAttr, + SendRawStun, + StunStatusCallBack); } static int -StartDiscussBindTransaction(int n) +StartENFBindTransaction(int n) { n = 0; /* hardcoded for now... TODO: fixme */ CurrAppCtx.a = AppCtx[n].a = 100 + n; CurrAppCtx.b = AppCtx[n].b = 200 + n; - discussData.streamType = 0x004; - discussData.interactivity = 0x01; - - discussData.networkStatus_flags = 0; - discussData.networkStatus_nodeCnt = 0; - discussData.networkStatus_tbd = 0; - discussData.networkStatus_upMaxBandwidth = 0; - discussData.networkStatus_downMaxBandwidth = 0; - + TransactionAttributes transAttr; + transAttr.transactionId = LastTransId; + transAttr.sockhandle = 0; + strncpy(transAttr.username, "pem", 4); + strncpy(transAttr.password, "pem", 4); + transAttr.peerPriority = 34567; + transAttr.useCandidate = false; + transAttr.iceControlling = false; + transAttr.tieBreaker = 4567; + transAttr.addEnf = true; + transAttr.enfFlowDescription.type = 0x04; + transAttr.enfFlowDescription.bandwidthMax = 4096; /* kick off stun */ return StunClient_startBindTransaction(stunInstance, @@ -194,20 +200,9 @@ StartDiscussBindTransaction(int n) NULL, 0, false, - "pem", - "pem", - 0, /* uint32_t 1845494271 - * (priority) */ - false, - false, - 0, /* uint64_t - * 0x932FF9B151263B36LL - * (tieBreaker) */ - LastTransId, - 0, /* socket */ - SendRawStun, /* send func */ - StunStatusCallBack, - &discussData); + &transAttr, + SendRawStun, + StunStatusCallBack); } static void @@ -240,9 +235,9 @@ SimBindSuccessResp(bool IPv6, m.xorMappedAddress.addr.v4.addr = test_addr_ipv4; m.xorMappedAddress.addr.v4.port = test_port_ipv4; } - m.hasTransCount = true; + m.hasTransCount = true; m.transCount.respCnt = 2; - m.transCount.reqCnt = lastReqCnt; + m.transCount.reqCnt = lastReqCnt; StunClient_HandleIncResp(stunInstance, &m, NULL); } @@ -334,8 +329,8 @@ CTEST(stunclient, logger) { StunClient_Alloc(&stunInstance); StunClient_RegisterLogger(stunInstance, - stundbg, - NULL); + stundbg, + NULL); StartBindTransaction(0); ASSERT_TRUE( 0 == strncmp("", logStr, 15) ); @@ -343,33 +338,28 @@ CTEST(stunclient, logger) CTEST(stunclient, bindtrans) { - int32_t ret = StunClient_startBindTransaction(NULL, - NULL, - (struct sockaddr*)&stunServerAddr, - NULL, - 0, - false, - "pem", - "pem", - 34567, - /* uint32_t - * 1845494271 - * (priority) */ - false, - false, - 4567, - /* uint64_t - * - * 0x932FF9B151263B36LL - * (tieBreaker) */ - LastTransId, - 0, - /* socket */ - SendRawStun, - /* send func */ - StunStatusCallBack, - NULL); - ASSERT_TRUE(ret == -1); + TransactionAttributes transAttr; + + transAttr.transactionId = LastTransId; + transAttr.sockhandle = 0; + strncpy(transAttr.username, "pem", 4); + strncpy(transAttr.password, "pem", 4); + transAttr.peerPriority = 34567; + transAttr.useCandidate = false; + transAttr.iceControlling = false; + transAttr.tieBreaker = 4567; + + /* kick off stun */ + int32_t ret = StunClient_startBindTransaction(stunInstance, + NULL, + (struct sockaddr*)&stunServerAddr, + NULL, + 0, + false, + &transAttr, + SendRawStun, + StunStatusCallBack); + ASSERT_TRUE(ret == 0); } @@ -516,13 +506,19 @@ CTEST(stunclient, DumpStats) StunClient_free(stunInstance); } -CTEST(stunclient, Send_Discuss) +CTEST(stunclient, Send_Enf) { StunClient_Alloc(&stunInstance); + StunClient_RegisterLogger(stunInstance, + stundbg, + NULL); sockaddr_initFromString( (struct sockaddr*)&stunServerAddr, "193.200.93.152:3478" ); - StartDiscussBindTransaction(0); - StunClient_HandleTick(stunInstance, STUN_TICK_INTERVAL_MS); + StartENFBindTransaction(0); + /* StunClient_HandleTick(stunInstance, STUN_TICK_INTERVAL_MS); */ + ASSERT_TRUE(lastEnfFlowType == 0x04); + ASSERT_TRUE(lastEnfFlowMaxBw == 4096); + SimBindSuccessResp(runningAsIPv6, true); ASSERT_TRUE(stunResult == StunResult_BindOk); diff --git a/test/stunserver_test.c b/test/stunserver_test.c index abfa635..991c360 100644 --- a/test/stunserver_test.c +++ b/test/stunserver_test.c @@ -22,12 +22,10 @@ StunResult_T stunResult; struct sockaddr_storage stunServerAddr; struct sockaddr_storage mappedAddr; -DiscussData discussData; - STUN_CLIENT_DATA* stunInstance; #define STUN_TICK_INTERVAL_MS 50 -const char passwd[] ="testtest"; +const char passwd[] = "testtest"; static void SendRawStun(void* ctx, @@ -61,9 +59,9 @@ SendRawStun(void* ctx, CTEST(stunserver, Encode_decode) { - StunMessage stunMsg; - StunMessage stunResponse; - StunMsgId stunId; + StunMessage stunMsg; + StunMessage stunResponse; + StunMsgId stunId; uint8_t stunBuff[STUN_MAX_PACKET_SIZE]; stunlib_createId(&stunId); @@ -72,24 +70,27 @@ CTEST(stunserver, Encode_decode) "193.200.93.152:3478" ); CreateConnectivityBindingResp(&stunMsg, stunId, - (struct sockaddr *)&mappedAddr, + (struct sockaddr*)&mappedAddr, 1, 1, + 0, + 0, + 0, + 0, STUN_MSG_BindResponseMsg, - 200, - NULL); + 200); int len = stunlib_encodeMessage(&stunMsg, (uint8_t*)stunBuff, STUN_MAX_PACKET_SIZE, - (unsigned char *) passwd, + (unsigned char*) passwd, strlen(passwd), - NULL); - ASSERT_TRUE(len == 72); + NULL); + ASSERT_TRUE( len == 72); - ASSERT_TRUE( stunlib_DecodeMessage(stunBuff, len, + ASSERT_TRUE( stunlib_DecodeMessage(stunBuff, len, &stunResponse, - NULL, NULL /*stdout for debug*/)); + NULL, NULL /*stdout for debug*/) ); } @@ -166,12 +167,15 @@ CTEST(stunserver, SendResp_Valid) servAddr, 0, 0, + 0, + 0, + 0, + 0, NULL, SendRawStun, 0, useRelay, - 0, /* responseCode */ - NULL) ); + 0) ); sockaddr_initFromString( (struct sockaddr*)&mappedAddr, "193.200.93.152:3478" ); ASSERT_TRUE( StunServer_SendConnectivityBindingResp(stunInstance, @@ -184,12 +188,15 @@ CTEST(stunserver, SendResp_Valid) servAddr, 2, 3, + 0, + 0, + 0, + 0, NULL, SendRawStun, 0, useRelay, - 0, - NULL) ); + 0) ); } @@ -197,8 +204,8 @@ CTEST(stunserver, SendResp_Valid_IPv6) { bool useRelay = false; struct sockaddr_storage mappedAddr,servAddr; - sockaddr_reset( &servAddr); - sockaddr_reset( &mappedAddr); + sockaddr_reset(&servAddr); + sockaddr_reset(&mappedAddr); sockaddr_initFromString( (struct sockaddr*)&servAddr, "[2a02:fe0:c410:cb31:e4d:e93f:fecb:bf6b]:1234" ); @@ -214,12 +221,15 @@ CTEST(stunserver, SendResp_Valid_IPv6) servAddr, 0, 0, + 0, + 0, + 0, + 0, NULL, SendRawStun, 0, useRelay, - 0, /* responseCode */ - NULL) ); + 0) ); sockaddr_initFromString( (struct sockaddr*)&mappedAddr, "[2a02:fe0:c410:cb31:e4d:e93f:fecb:bf6b]:1234" ); ASSERT_TRUE( StunServer_SendConnectivityBindingResp(stunInstance, @@ -232,53 +242,14 @@ CTEST(stunserver, SendResp_Valid_IPv6) servAddr, 0, 0, + 0, + 0, + 0, + 0, NULL, SendRawStun, 0, useRelay, - 0, - NULL) ); - -} - - -CTEST(stunserver, SendDiscussResp_Valid) -{ - bool useRelay = false; - - discussData.streamType = 0x004; - discussData.interactivity = 0x01; - - discussData.networkStatus_flags = 0; - discussData.networkStatus_nodeCnt = 0; - discussData.networkStatus_tbd = 0; - discussData.networkStatus_upMaxBandwidth = 0; - discussData.networkStatus_downMaxBandwidth = 0; - - sockaddr_initFromString( (struct sockaddr*)&stunServerAddr, - "193.200.93.152:3478" ); - - StunClient_Alloc(&stunInstance); - ASSERT_TRUE( StunServer_SendConnectivityBindingResp(stunInstance, - 0, /* sockhandle */ - LastTransId, - "pem", - (struct sockaddr*)& - stunServerAddr, - (struct sockaddr*)& - stunServerAddr, - 2, - 2, - NULL, - SendRawStun, - 0, - useRelay, - 0, /* responseCode */ - &discussData) ); - -} - -CTEST(stunserver, SendResp_InValid) -{ + 0) ); } diff --git a/test/stuntrace_test.c b/test/stuntrace_test.c index 6144b70..af15cce 100644 --- a/test/stuntrace_test.c +++ b/test/stuntrace_test.c @@ -29,8 +29,8 @@ stundbg(void* ctx, (void) category; (void) ctx; (void) errStr; -// strncpy(logStr, errStr, sizeof logStr); -// printf("%s\n", errStr); +/* strncpy(logStr, errStr, sizeof logStr); */ +/* printf("%s\n", errStr); */ } static void @@ -582,13 +582,13 @@ CTEST(stuntrace, run_IPv4_Stunresp) ASSERT_TRUE(LastTTL == 40); sockaddr_initFromString( (struct sockaddr*)&hop1Addr, "192.168.1.1:45674" ); - StunClient_HandleICMP(clientData, + StunClient_HandleICMP(clientData, (struct sockaddr*)&hop1Addr, 11); ASSERT_FALSE( sockaddr_alike( (struct sockaddr*)&LastHopAddr, - (struct sockaddr*)&hop1Addr ) ); + (struct sockaddr*)&hop1Addr ) ); - ASSERT_TRUE( LastTTL == 40); + ASSERT_TRUE(LastTTL == 40); sockaddr_initFromString( (struct sockaddr*)&hop2Addr, "193.200.93.152:45674" ); diff --git a/test/testvector_print_test.c b/test/testvector_print_test.c index 2aae483..06677de 100644 --- a/test/testvector_print_test.c +++ b/test/testvector_print_test.c @@ -902,55 +902,27 @@ CTEST(testvector, SendIndication) } -CTEST(testvector, discuss_encode_decode) +CTEST(testvector, enf_encode_decode) { FILE* file; file = fopen("test_vector.txt", "w+"); StunMessage stunMsg; unsigned char stunBuf[STUN_MAX_PACKET_SIZE]; - DiscussData discussData; - discussData.streamType = 0x004; - discussData.interactivity = 0x01; - - discussData.bandwidthUsage_average = 34; - discussData.bandwidthUsage_max = 56; - - discussData.networkStatus_flags = 0; - discussData.networkStatus_nodeCnt = 0; - discussData.networkStatus_tbd = 0; - discussData.networkStatus_upMaxBandwidth = 0; - discussData.networkStatus_downMaxBandwidth = 0; memset( &stunMsg, 0, sizeof(StunMessage) ); stunMsg.msgHdr.msgType = STUN_MSG_AllocateRequestMsg; memcpy(&stunMsg.msgHdr.id.octet,&idOctet,12); - stunMsg.hasStreamType = true; - stunMsg.streamType.type = discussData.streamType; - stunMsg.streamType.interactivity = discussData.interactivity; - - stunMsg.hasBandwidthUsage = true; - stunMsg.bandwidthUsage.average = discussData.bandwidthUsage_average; - stunMsg.bandwidthUsage.max = discussData.bandwidthUsage_max; - + stunMsg.hasEnfFlowDescription = true; + stunMsg.enfFlowDescription.type = 4; + stunMsg.enfFlowDescription.bandwidthMax = 4096; - - stunMsg.hasNetworkStatus = true; - stunMsg.networkStatus.flags = 0; - stunMsg.networkStatus.nodeCnt = 0; - stunMsg.networkStatus.upMaxBandwidth = 0; - stunMsg.networkStatus.downMaxBandwidth = 0; - - stunMsg.hasNetworkStatusResp = true; - stunMsg.networkStatusResp.flags = - discussData.networkStatusResp_flags; - stunMsg.networkStatusResp.nodeCnt = - discussData.networkStatusResp_nodeCnt; - stunMsg.networkStatusResp.upMaxBandwidth = - discussData.networkStatusResp_upMaxBandwidth; - stunMsg.networkStatusResp.downMaxBandwidth = - discussData.networkStatusResp_downMaxBandwidth; + stunMsg.hasEnfNetworkStatus = true; + stunMsg.enfNetworkStatus.flags = 0; + stunMsg.enfNetworkStatus.nodeCnt = 0; + stunMsg.enfNetworkStatus.upMaxBandwidth = 0; + stunMsg.enfNetworkStatus.downMaxBandwidth = 0; stunlib_encodeMessage(&stunMsg, stunBuf, @@ -972,88 +944,6 @@ CTEST(testvector, discuss_encode_decode) sizeof(password) ) ); - ASSERT_TRUE(stunMsg.streamType.type == discussData.streamType); - ASSERT_TRUE(stunMsg.streamType.interactivity == discussData.interactivity); - - ASSERT_TRUE( - stunMsg.bandwidthUsage.average == discussData.bandwidthUsage_average); - ASSERT_TRUE(stunMsg.bandwidthUsage.max == discussData.bandwidthUsage_max); - - ASSERT_TRUE( - stunMsg.networkStatusResp.flags == discussData.networkStatusResp_flags); - ASSERT_TRUE( - stunMsg.networkStatusResp.nodeCnt == discussData.networkStatusResp_nodeCnt); - ASSERT_TRUE( - stunMsg.networkStatusResp.upMaxBandwidth == - discussData.networkStatusResp_upMaxBandwidth); - ASSERT_TRUE( - stunMsg.networkStatusResp.downMaxBandwidth == - discussData.networkStatusResp_downMaxBandwidth); - fclose(file); - remove("test_vector.txt"); - -} - - - -CTEST(testvector, cisco_network_feedback_enc_dec) -{ - FILE* file; - file = fopen("test_vector.txt", "w+"); - StunMessage stunMsg; - unsigned char stunBuf[STUN_MAX_PACKET_SIZE]; - - uint32_t first_val = 42; - uint32_t second_val = 0x0; - uint32_t third_val = 5678923; - - - memset( &stunMsg, 0, sizeof(StunMessage) ); - stunMsg.msgHdr.msgType = STUN_MSG_AllocateRequestMsg; - memcpy(&stunMsg.msgHdr.id.octet,&idOctet,12); - - /* After Integrity attribute */ - stunMsg.hasCiscoNetFeed = true; - stunMsg.ciscoNetFeed.first = first_val; - stunMsg.ciscoNetFeed.second = second_val; - stunMsg.ciscoNetFeed.third = third_val; - - /* This is Integrity protected */ - stunMsg.hasCiscoNetFeedResp = true; - stunMsg.ciscoNetFeedResp.first = first_val; - stunMsg.ciscoNetFeedResp.second = second_val; - stunMsg.ciscoNetFeedResp.third = third_val; - - ASSERT_TRUE( stunlib_encodeMessage(&stunMsg, - stunBuf, - sizeof(stunBuf), - (unsigned char*)password, - strlen(password), - file) ); - - memset( &stunMsg, 0, sizeof(StunMessage) ); - - ASSERT_TRUE( stunlib_DecodeMessage(stunBuf, - sizeof(stunBuf), - &stunMsg, - NULL, - file) ); - - ASSERT_TRUE( stunlib_checkIntegrity( stunBuf, - sizeof(stunBuf), - &stunMsg, - (uint8_t*)password, - sizeof(password) ) ); - - ASSERT_TRUE(stunMsg.hasCiscoNetFeed); - ASSERT_TRUE(stunMsg.ciscoNetFeed.first == first_val); - ASSERT_TRUE(stunMsg.ciscoNetFeed.second == second_val); - ASSERT_TRUE(stunMsg.ciscoNetFeed.third == third_val); - - ASSERT_TRUE(stunMsg.hasCiscoNetFeedResp); - ASSERT_TRUE(stunMsg.ciscoNetFeedResp.first == first_val); - ASSERT_TRUE(stunMsg.ciscoNetFeedResp.second == second_val); - ASSERT_TRUE(stunMsg.ciscoNetFeedResp.third == third_val); fclose(file); remove("test_vector.txt"); diff --git a/test/testvector_test.c b/test/testvector_test.c index d73eeeb..8afee47 100644 --- a/test/testvector_test.c +++ b/test/testvector_test.c @@ -847,53 +847,37 @@ CTEST(testvector, SendIndication) } -CTEST(testvector, discuss_encode_decode) +CTEST(testvector, enf_encode_decode) { StunMessage stunMsg; unsigned char stunBuf[STUN_MAX_PACKET_SIZE]; - DiscussData discussData; - - discussData.streamType = 0x004; - discussData.interactivity = 0x01; - - discussData.bandwidthUsage_average = 34; - discussData.bandwidthUsage_max = 56; - - discussData.networkStatus_flags = 0; - discussData.networkStatus_nodeCnt = 0; - discussData.networkStatus_tbd = 0; - discussData.networkStatus_upMaxBandwidth = 0; - discussData.networkStatus_downMaxBandwidth = 0; - + uint8_t type = 0x04; + uint8_t tbd = 0x00; + uint16_t bw_max = 4096; memset( &stunMsg, 0, sizeof(StunMessage) ); stunMsg.msgHdr.msgType = STUN_MSG_AllocateRequestMsg; memcpy(&stunMsg.msgHdr.id.octet,&idOctet,12); - stunMsg.hasStreamType = true; - stunMsg.streamType.type = discussData.streamType; - stunMsg.streamType.interactivity = discussData.interactivity; - - stunMsg.hasBandwidthUsage = true; - stunMsg.bandwidthUsage.average = discussData.bandwidthUsage_average; - stunMsg.bandwidthUsage.max = discussData.bandwidthUsage_max; + /* Flow Descr */ + stunMsg.hasEnfFlowDescription = true; + stunMsg.enfFlowDescription.type = type; + stunMsg.enfFlowDescription.tbd = tbd; + stunMsg.enfFlowDescription.bandwidthMax = bw_max; + stunMsg.enfFlowDescription.pad = 0x00; + stunMsg.hasEnfNetworkStatus = true; + stunMsg.enfNetworkStatus.flags = 0x1; + stunMsg.enfNetworkStatus.nodeCnt = 4; + stunMsg.enfNetworkStatus.upMaxBandwidth = 34; + stunMsg.enfNetworkStatus.downMaxBandwidth = 3456; - stunMsg.hasNetworkStatus = true; - stunMsg.networkStatus.flags = 0; - stunMsg.networkStatus.nodeCnt = 0; - stunMsg.networkStatus.upMaxBandwidth = 0; - stunMsg.networkStatus.downMaxBandwidth = 0; + stunMsg.hasEnfNetworkStatusResp = true; + stunMsg.enfNetworkStatusResp.flags = 0x5; + stunMsg.enfNetworkStatusResp.nodeCnt = 7; + stunMsg.enfNetworkStatusResp.upMaxBandwidth = 4098; + stunMsg.enfNetworkStatusResp.downMaxBandwidth = 6789; - stunMsg.hasNetworkStatusResp = true; - stunMsg.networkStatusResp.flags = - discussData.networkStatusResp_flags; - stunMsg.networkStatusResp.nodeCnt = - discussData.networkStatusResp_nodeCnt; - stunMsg.networkStatusResp.upMaxBandwidth = - discussData.networkStatusResp_upMaxBandwidth; - stunMsg.networkStatusResp.downMaxBandwidth = - discussData.networkStatusResp_downMaxBandwidth; stunlib_encodeMessage(&stunMsg, stunBuf, @@ -914,87 +898,29 @@ CTEST(testvector, discuss_encode_decode) (uint8_t*)password, sizeof(password) ) ); + ASSERT_TRUE(stunMsg.hasEnfFlowDescription); + ASSERT_TRUE(stunMsg.enfFlowDescription.type == type); + ASSERT_TRUE(stunMsg.enfFlowDescription.tbd == tbd); + ASSERT_TRUE(stunMsg.enfFlowDescription.bandwidthMax == bw_max); + ASSERT_TRUE(stunMsg.enfFlowDescription.pad == 0); - ASSERT_TRUE(stunMsg.streamType.type == discussData.streamType); - ASSERT_TRUE(stunMsg.streamType.interactivity == discussData.interactivity); + ASSERT_TRUE(stunMsg.hasEnfNetworkStatus); + ASSERT_TRUE(stunMsg.enfNetworkStatus.flags == 0x1); + ASSERT_TRUE(stunMsg.enfNetworkStatus.nodeCnt == 4); + ASSERT_TRUE(stunMsg.enfNetworkStatus.upMaxBandwidth == 34); + ASSERT_TRUE(stunMsg.enfNetworkStatus.downMaxBandwidth == 3456); - ASSERT_TRUE( - stunMsg.bandwidthUsage.average == discussData.bandwidthUsage_average); - ASSERT_TRUE(stunMsg.bandwidthUsage.max == discussData.bandwidthUsage_max); + ASSERT_TRUE(stunMsg.hasEnfNetworkStatusResp); + ASSERT_TRUE(stunMsg.enfNetworkStatusResp.flags == 0x5); + ASSERT_TRUE(stunMsg.enfNetworkStatusResp.nodeCnt == 7); + ASSERT_TRUE(stunMsg.enfNetworkStatusResp.upMaxBandwidth == 4098); + ASSERT_TRUE(stunMsg.enfNetworkStatusResp.downMaxBandwidth == 6789); - ASSERT_TRUE( - stunMsg.networkStatusResp.flags == discussData.networkStatusResp_flags); - ASSERT_TRUE( - stunMsg.networkStatusResp.nodeCnt == discussData.networkStatusResp_nodeCnt); - ASSERT_TRUE( - stunMsg.networkStatusResp.upMaxBandwidth == - discussData.networkStatusResp_upMaxBandwidth); - ASSERT_TRUE( - stunMsg.networkStatusResp.downMaxBandwidth == - discussData.networkStatusResp_downMaxBandwidth); } -CTEST(testvector, cisco_network_feedback_enc_dec) -{ - StunMessage stunMsg; - unsigned char stunBuf[STUN_MAX_PACKET_SIZE]; - - uint32_t first_val = 42; - uint32_t second_val = 0x0; - uint32_t third_val = 5678923; - - - memset( &stunMsg, 0, sizeof(StunMessage) ); - stunMsg.msgHdr.msgType = STUN_MSG_AllocateRequestMsg; - memcpy(&stunMsg.msgHdr.id.octet,&idOctet,12); - - /* After Integrity attribute */ - stunMsg.hasCiscoNetFeed = true; - stunMsg.ciscoNetFeed.first = first_val; - stunMsg.ciscoNetFeed.second = second_val; - stunMsg.ciscoNetFeed.third = third_val; - - /* This is Integrity protected */ - stunMsg.hasCiscoNetFeedResp = true; - stunMsg.ciscoNetFeedResp.first = first_val; - stunMsg.ciscoNetFeedResp.second = second_val; - stunMsg.ciscoNetFeedResp.third = third_val; - - ASSERT_TRUE( stunlib_encodeMessage(&stunMsg, - stunBuf, - sizeof(stunBuf), - (unsigned char*)password, - strlen(password), - NULL) ); - - memset( &stunMsg, 0, sizeof(StunMessage) ); - - ASSERT_TRUE( stunlib_DecodeMessage(stunBuf, - sizeof(stunBuf), - &stunMsg, - NULL, - NULL) ); - - ASSERT_TRUE( stunlib_checkIntegrity( stunBuf, - sizeof(stunBuf), - &stunMsg, - (uint8_t*)password, - sizeof(password) ) ); - - ASSERT_TRUE(stunMsg.hasCiscoNetFeed); - ASSERT_TRUE(stunMsg.ciscoNetFeed.first == first_val); - ASSERT_TRUE(stunMsg.ciscoNetFeed.second == second_val); - ASSERT_TRUE(stunMsg.ciscoNetFeed.third == third_val); - - ASSERT_TRUE(stunMsg.hasCiscoNetFeedResp); - ASSERT_TRUE(stunMsg.ciscoNetFeedResp.first == first_val); - ASSERT_TRUE(stunMsg.ciscoNetFeedResp.second == second_val); - ASSERT_TRUE(stunMsg.ciscoNetFeedResp.third == third_val); -} - CTEST(testvector, dont_crash_if_atrLen_bogus_on_errors_messages) { unsigned char id_000387_src_000097_op_havoc_rep_8[] = { diff --git a/test/turnclient_test.c b/test/turnclient_test.c index 7683407..62901cd 100644 --- a/test/turnclient_test.c +++ b/test/turnclient_test.c @@ -164,9 +164,9 @@ SimAllocResp(int ctx, } else { - memcpy( &m.msgHdr.id, &LastTransId, STUN_MSG_ID_SIZE); + memcpy(&m.msgHdr.id, &LastTransId, STUN_MSG_ID_SIZE); } - memcpy( &m.msgHdr.cookie, StunCookie, sizeof(m.msgHdr.cookie) ); + memcpy( &m.msgHdr.cookie, StunCookie, sizeof(m.msgHdr.cookie) ); m.msgHdr.msgType = STUN_MSG_AllocateResponseMsg; /* relay */ @@ -223,7 +223,7 @@ SimAllocResp(int ctx, m.lifetime.value = 60; } - TurnClient_HandleIncResp(pInst, &m, NULL); + TurnClient_HandleIncResp(pInst, &m, NULL); if (duplicate) { @@ -525,36 +525,36 @@ CTEST(turnclient, startAllocation_NULL) CTEST(turnclient, startAllocation_even) { ASSERT_TRUE( TurnClient_StartAllocateTransaction(&pInst, - 50, - NULL, - "test", - NULL, - NULL, - "pem", - "pem", - AF_INET6, - SendRawStun, - TurnStatusCallBack, - true, - 0) ); + 50, + NULL, + "test", + NULL, + NULL, + "pem", + "pem", + AF_INET6, + SendRawStun, + TurnStatusCallBack, + true, + 0) ); } CTEST(turnclient, startAllocation_odd) { ASSERT_TRUE( TurnClient_StartAllocateTransaction(&pInst, - 50, - NULL, - "test", - NULL, - NULL, - "pem", - "pem", - AF_INET6, - SendRawStun, - TurnStatusCallBack, - true, - 45678) ); + 50, + NULL, + "test", + NULL, + NULL, + "pem", + "pem", + AF_INET6, + SendRawStun, + TurnStatusCallBack, + true, + 45678) ); } @@ -626,7 +626,7 @@ CTEST(turnclient, WaitAllocRespNotAut_AllocRspOk) SimAllocResp(ctx, true, true, true, runningAsIPv6, true, false); ASSERT_TRUE(turnResult == TurnResult_AllocOk); ASSERT_FALSE( TurnClient_hasBeenRedirected(pInst) ); - ASSERT_FALSE( TurnClient_hasBeenRedirected(NULL ) ); + ASSERT_FALSE( TurnClient_hasBeenRedirected(NULL) ); TurnClient_Deallocate(pInst); Sim_RefreshResp(ctx); @@ -640,7 +640,7 @@ CTEST(turnclient, WaitAllocRespNotAut_AllocRspDuplicate) ctx = StartAllocateTransaction(); TurnClient_HandleTick(pInst); SimAllocResp(ctx, true, true, true, runningAsIPv6, true, true); - ASSERT_FALSE(turnResult == TurnResult_AllocOk); + ASSERT_FALSE( turnResult == TurnResult_AllocOk); ASSERT_FALSE( TurnClient_hasBeenRedirected(pInst) ); TurnClient_Deallocate(pInst); @@ -1346,7 +1346,7 @@ CTEST(turnclient, Allocated_CreatePermissionReqOk) struct sockaddr_storage* p_peerIp[6]; int ctx; uint32_t i; - TurnStats_T stats; + TurnStats_T stats; for (i = 0; i < sizeof(peerIp) / sizeof(peerIp[0]); i++) {