/** * Creates and adds a Vendor-Specifig-Application-ID AVP. * @param msg - the Diameter message to add to. * @param vendor_id - the value of the vendor_id, * @param auth_id - the authorization application id * @param acct_id - the accounting application id * @returns 1 on success or 0 on error */ inline int Ro_add_vendor_specific_appid(AAAMessage *msg, unsigned int vendor_id, unsigned int auth_id, unsigned int acct_id) { AAA_AVP_LIST list; str group; char x[4]; list.head = 0; list.tail = 0; set_4bytes(x, vendor_id); Ro_add_avp_list(&list, x, 4, AVP_Vendor_Id, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); if (auth_id) { set_4bytes(x, auth_id); Ro_add_avp_list(&list, x, 4, AVP_Auth_Application_Id, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); } if (acct_id) { set_4bytes(x, acct_id); Ro_add_avp_list(&list, x, 4, AVP_Acct_Application_Id, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); } group = cdpb.AAAGroupAVPS(list); cdpb.AAAFreeAVPList(&list); return Ro_add_avp(msg, group.s, group.len, AVP_Vendor_Specific_Application_Id, AAA_AVP_FLAG_MANDATORY, 0, AVP_FREE_DATA, __FUNCTION__); }
/** * Send a Capability Exchange Request. * \note Must be called with a lock on the peer. * @param p - the peer to send to */ void I_Snd_CER(peer *p) { AAAMessage *cer=0; // AAA_AVP *avp; unsigned long ip; struct sockaddr_in addr; socklen_t addrlen; char x[6]; cer = AAANewMessage(Code_CE,0,0,0); if (!cer) return; cer->hopbyhopId = next_hopbyhop(); cer->endtoendId = next_endtoend(); addrlen = sizeof(struct sockaddr_in); if (getsockname(p->I_sock,(struct sockaddr*) &addr, &addrlen) == -1) { LOG(L_ERR,"ERROR:I_Snd_CER(): Error on finding local host address > %s\n",strerror(errno)); }else{ set_2bytes(x,1); ip = htonl(addr.sin_addr.s_addr); set_4bytes(x+2,ip); AAACreateAndAddAVPToMessage(cer,AVP_Host_IP_Address,AAA_AVP_FLAG_MANDATORY,0,x,6); } set_4bytes(x,config->vendor_id); AAACreateAndAddAVPToMessage(cer,AVP_Vendor_Id,AAA_AVP_FLAG_MANDATORY,0,x,4); AAACreateAndAddAVPToMessage(cer,AVP_Product_Name,AAA_AVP_FLAG_MANDATORY,0,config->product_name.s,config->product_name.len); Snd_CE_add_applications(cer,p); // peer_send(p,p->I_sock,cer,1); peer_send_msg(p,cer); }
/** * Send a Capabilities Exchange Answer. * Checks whether there are common applications. * \note Must be called with a lock on the peer. * @param p - peer identification * @param cer - the CER message * @param result_code - the Result-Code to send * @param sock - socket to send through */ void Snd_CEA(peer *p,AAAMessage *cer,int result_code,int sock) { AAAMessage *cea; unsigned int ip; struct sockaddr_in addr; socklen_t addrlen; char x[6]; cea = AAANewMessage(Code_CE,0,0,cer); if (!cea) goto done; addrlen = sizeof(struct sockaddr_in); if (getsockname(sock,(struct sockaddr*) &addr, &addrlen) == -1) { LOG(L_ERR,"ERROR:Snd_CEA(): Error on finding local host address > %s\n",strerror(errno)); }else{ set_2bytes(x,1); ip = htonl(addr.sin_addr.s_addr); set_4bytes(x+2,ip); AAACreateAndAddAVPToMessage(cea,AVP_Host_IP_Address,AAA_AVP_FLAG_MANDATORY,0,x,6); } set_4bytes(x,config->vendor_id); AAACreateAndAddAVPToMessage(cea,AVP_Vendor_Id,AAA_AVP_FLAG_MANDATORY,0,x,4); AAACreateAndAddAVPToMessage(cea,AVP_Product_Name,AAA_AVP_FLAG_MANDATORY,0,config->product_name.s,config->product_name.len); set_4bytes(x,result_code); AAACreateAndAddAVPToMessage(cea,AVP_Result_Code,AAA_AVP_FLAG_MANDATORY,0,x,4); Snd_CE_add_applications(cea,p); peer_send(p,sock,cea,1); done: AAAFreeMessage(&cer); }
int AAAAVPBuildBuffer(AAA_AVP *avp, unsigned char *dest) { unsigned char* p = dest; if (!avp || !dest) { ERROR("trying to build msg buffer from/to NULL avp"); return 0; } /* AVP HEADER */ /* avp code */ set_4bytes(p,avp->code); p +=4; /* flags */ (*p++) = (unsigned char)avp->flags; /* avp length */ set_3bytes(p, (AVP_HDR_SIZE(avp->flags)+avp->data.len) ); p += 3; /* vendor id */ if ((avp->flags&0x80)!=0) { set_4bytes(p,avp->vendorId); p +=4; } /* data */ memcpy( p, avp->data.s, avp->data.len); p += to_32x_len( avp->data.len ); return p-dest; }
void Send_ASR(cdp_session_t* s, AAAMessage* msg) { AAAMessage *asr = 0; AAA_AVP *avp = 0; peer *p = 0; char x[4]; LM_DBG("Send_ASR() : sending ASR\n"); asr = AAACreateRequest(s->application_id, IMS_ASR, Flag_Proxyable, s); if (!asr) { LM_ERR("Send_ASR(): error creating ASR!\n"); return; } set_4bytes(x, s->application_id); avp = AAACreateAVP(AVP_Auth_Application_Id, AAA_AVP_FLAG_MANDATORY, 0, x, 4, AVP_DUPLICATE_DATA); AAAAddAVPToMessage(asr, avp, asr->avpList.tail); set_4bytes(x, 3); // Not specified avp = AAACreateAVP(AVP_IMS_Abort_Cause, AAA_AVP_FLAG_MANDATORY, 0, x, 4, AVP_DUPLICATE_DATA); AAAAddAVPToMessage(asr, avp, asr->avpList.tail); //todo - add all the other avps p = get_routing_peer(s, asr); if (!p) { LM_ERR("unable to get routing peer in Send_ASR \n"); if (asr) AAAFreeMessage(&asr); //needed in frequency } if (!peer_send_msg(p, asr)) { if (asr) AAAFreeMessage(&asr); //needed in frequency } else LM_DBG("success sending ASR\n"); }
inline int Ro_add_cc_request(AAAMessage *msg, unsigned int cc_request_type, unsigned int cc_request_number) { char x[4]; set_4bytes(x, cc_request_type); int success = Ro_add_avp(msg, x, 4, AVP_CC_Request_Type, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); char y[4]; set_4bytes(y, cc_request_number); return success && Ro_add_avp(msg, y, 4, AVP_CC_Request_Number, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); }
/** * Groups a list of avps into a data buffer * @param avps */ str AAAGroupAVPS(AAA_AVP_LIST avps) { AAA_AVP *avp; unsigned char *p; str buf={0,0}; /* count and add the avps */ for(avp=avps.head;avp;avp=avp->next) { buf.len += AVP_HDR_SIZE(avp->flags)+ to_32x_len( avp->data.len ); } if (!buf.len) return buf; /* allocate some memory */ buf.s = (char*)shm_malloc( buf.len ); if (!buf.s) { LM_ERR("hss3g_group_avps: no more free memory!\n"); buf.len=0; return buf; } memset(buf.s, 0, buf.len); /* fill in the buffer */ p = (unsigned char*) buf.s; for(avp=avps.head;avp;avp=avp->next) { /* AVP HEADER */ /* avp code */ set_4bytes(p,avp->code); p +=4; /* flags */ (*p++) = (unsigned char)avp->flags; /* avp length */ set_3bytes(p, (AVP_HDR_SIZE(avp->flags)+avp->data.len) ); p += 3; /* vendor id */ if ((avp->flags&0x80)!=0) { set_4bytes(p,avp->vendorId); p +=4; } /* data */ memcpy( p, avp->data.s, avp->data.len); p += to_32x_len( avp->data.len ); } if ((char*)p-buf.s!=buf.len) { LM_ERR("BUG:hss3g_group_avps: mismatch between len and buf!\n"); shm_free( buf.s ); buf.s = 0; buf.len = 0; return buf; } return buf; }
/** * Send a Capabilities Exchange Answer. * Checks whether there are common applications. * \note Must be called with a lock on the peer. * @param p - peer identification * @param cer - the CER message * @param result_code - the Result-Code to send * @param sock - socket to send through */ void Snd_CEA(peer *p,AAAMessage *cer,int result_code,int sock) { AAAMessage *cea; unsigned int ip; union { struct sockaddr addr; struct sockaddr_in in; struct sockaddr_in6 in6; } addr_u ; socklen_t addrlen; char x[18]; cea = AAANewMessage(Code_CE,0,0,cer); if (!cea) goto done; addrlen = sizeof(addr_u); if (getsockname(sock, &(addr_u.addr), &addrlen) == -1) { LM_ERR("Snd_CEA(): Error on finding local host address > %s\n",strerror(errno)); }else{ switch(addr_u.addr.sa_family){ case AF_INET: set_2bytes(x,1); ip = htonl(addr_u.in.sin_addr.s_addr); set_4bytes(x+2,ip); AAACreateAndAddAVPToMessage(cea,AVP_Host_IP_Address,AAA_AVP_FLAG_MANDATORY,0,x,6); break; case AF_INET6: set_2bytes(x,2); memcpy(x+2,addr_u.in6.sin6_addr.s6_addr,16); AAACreateAndAddAVPToMessage(cea,AVP_Host_IP_Address,AAA_AVP_FLAG_MANDATORY,0,x,18); break; default: LM_ERR("Snd_CEA(): unknown address type with family %d\n",addr_u.addr.sa_family); } } set_4bytes(x,config->vendor_id); AAACreateAndAddAVPToMessage(cea,AVP_Vendor_Id,AAA_AVP_FLAG_MANDATORY,0,x,4); AAACreateAndAddAVPToMessage(cea,AVP_Product_Name,AAA_AVP_FLAG_MANDATORY,0,config->product_name.s,config->product_name.len); set_4bytes(x,result_code); AAACreateAndAddAVPToMessage(cea,AVP_Result_Code,AAA_AVP_FLAG_MANDATORY,0,x,4); Snd_CE_add_applications(cea,p); peer_send(p,sock,cea,1); done: AAAFreeMessage(&cer); }
void Send_STR(cdp_session_t* s, AAAMessage* msg) { AAAMessage *str=0; AAA_AVP *avp=0; peer *p=0; char x[4]; LOG(L_DBG, "sending STR\n"); //if (msg) LOG(L_DBG,"Send_STR() : sending STR for %d, flags %#1x endtoend %u hopbyhop %u\n",msg->commandCode,msg->flags,msg->endtoendId,msg->hopbyhopId); //else LOG(L_DBG,"Send_STR() called from AAATerminateAuthSession or some other event\n"); str = AAACreateRequest(s->application_id,IMS_STR,Flag_Proxyable,s); if (!str) { LOG(L_ERR,"ERR:Send_STR(): error creating STR!\n"); return; } if(!dup_routing_avps(msg, str)){ LOG(L_ERR,"ERR:Send_STR(): error duplicating routing AVPs!\n"); AAAFreeMessage(&str); return; } if(s->vendor_id!=0 && !add_vendor_specific_application_id_group(str,s->vendor_id,s->application_id)){ LOG(L_ERR,"ERR:Send_STR(): error adding Vendor-Id-Specific-Application-Id Group!\n"); AAAFreeMessage(&str); return; } set_4bytes(x,s->application_id); avp = AAACreateAVP(AVP_Auth_Application_Id,AAA_AVP_FLAG_MANDATORY,0,x,4,AVP_DUPLICATE_DATA); AAAAddAVPToMessage(str,avp,str->avpList.tail); set_4bytes(x,4); // Diameter_administrative avp = AAACreateAVP(AVP_Termination_Cause,AAA_AVP_FLAG_MANDATORY,0,x,4,AVP_DUPLICATE_DATA); AAAAddAVPToMessage(str,avp,str->avpList.tail); //todo - add all the other avps p = get_routing_peer(str); if (!p) { LOG(L_ERR,"unable to get routing peer in Send_STR \n"); if (str) AAAFreeMessage(&str); //needed in frequency return; } //if (str) LOG(L_CRIT,"Send_STR() : sending STR %d, flags %#1x endtoend %u hopbyhop %u\n",str->commandCode,str->flags,str->endtoendId,str->hopbyhopId); if (!peer_send_msg(p,str)) { LOG(L_DBG,"Send_STR peer_send_msg return error!\n"); if (str) AAAFreeMessage(&str); //needed in frequency } else { LOG(L_DBG,"success sending STR\n"); } }
AAAMessage *send_unknown_request_answer(AAAMessage *req) { AAAMessage *ans=0; char x[4]; AAA_AVP *avp; /* UAA header is created based on the UAR */ ans = AAANewMessage(req->commandCode,req->applicationId,0,req); if (!ans) return 0; set_4bytes(x,(unsigned int) DIAMETER_UNABLE_TO_COMPLY); avp = AAACreateAVP(AVP_Result_Code,AAA_AVP_FLAG_MANDATORY,0,x,4,AVP_DUPLICATE_DATA); if (!avp) { LOG(L_ERR,"ERR: Failed creating avp for result code\n"); AAAFreeMessage(&ans); return 0; } if (AAAAddAVPToMessage(ans,avp,ans->avpList.tail)!=AAA_ERR_SUCCESS) { LOG(L_ERR,"ERR: Failed adding avp to message\n"); AAAFreeAVP(&avp); AAAFreeMessage(&ans); return 0; } return ans; }
inline AAA_AVP *cdp_avp_new_Integer32(int avp_code,int avp_flags,int avp_vendorid,int32_t data) { char x[4]; str s={x,4}; set_4bytes(x,data); return cdp_avp_new(avp_code,avp_flags,avp_vendorid,s,AVP_DUPLICATE_DATA); }
/** * Send a Capability Exchange Request. * \note Must be called with a lock on the peer. * @param p - the peer to send to */ void I_Snd_CER(peer *p) { AAAMessage *cer=0; // AAA_AVP *avp; unsigned long ip; union { struct sockaddr addr; struct sockaddr_in in; struct sockaddr_in6 in6; } addr_u ; socklen_t addrlen; char x[18]; cer = AAANewMessage(Code_CE,0,0,0); if (!cer) return; cer->hopbyhopId = next_hopbyhop(); cer->endtoendId = next_endtoend(); addrlen = sizeof(addr_u); if (getsockname(p->I_sock,&(addr_u.addr), &addrlen) == -1) { LM_ERR("I_Snd_CER(): Error on finding local host address > %s\n",strerror(errno)); }else{ switch(addr_u.addr.sa_family){ case AF_INET: set_2bytes(x,1); ip = htonl(addr_u.in.sin_addr.s_addr); set_4bytes(x+2,ip); AAACreateAndAddAVPToMessage(cer,AVP_Host_IP_Address,AAA_AVP_FLAG_MANDATORY,0,x,6); break; case AF_INET6: set_2bytes(x,2); memcpy(x+2,addr_u.in6.sin6_addr.s6_addr,16); AAACreateAndAddAVPToMessage(cer,AVP_Host_IP_Address,AAA_AVP_FLAG_MANDATORY,0,x,18); break; default: LM_ERR("I_Snd_CER(): unknown address type with family %d\n",addr_u.addr.sa_family); } } set_4bytes(x,config->vendor_id); AAACreateAndAddAVPToMessage(cer,AVP_Vendor_Id,AAA_AVP_FLAG_MANDATORY,0,x,4); AAACreateAndAddAVPToMessage(cer,AVP_Product_Name,AAA_AVP_FLAG_MANDATORY,0,config->product_name.s,config->product_name.len); Snd_CE_add_applications(cer,p); // peer_send(p,p->I_sock,cer,1); peer_send_msg(p,cer); }
inline int Ro_add_multiple_service_credit_Control(AAAMessage *msg, unsigned int requested_unit, int used_unit, int active_rating_group, int active_service_identifier) { // Add Multiple-Services AVP Indicator char x[4]; set_4bytes(x, 1); Ro_add_avp(msg, x, 4, AVP_Multiple_Services_Indicator, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); AAA_AVP_LIST list, used_list, mscc_list; str group, used_group; list.head = 0; list.tail = 0; used_list.head = 0; used_list.tail = 0; mscc_list.head = 0; mscc_list.tail = 0; set_4bytes(x, requested_unit); Ro_add_avp_list(&list, x, 4, AVP_CC_Time, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); group = cdpb.AAAGroupAVPS(list); cdpb.AAAFreeAVPList(&list); Ro_add_avp_list(&mscc_list, group.s, group.len, AVP_Requested_Service_Unit, AAA_AVP_FLAG_MANDATORY, 0, AVP_FREE_DATA, __FUNCTION__); set_4bytes(x, active_service_identifier); Ro_add_avp_list(&mscc_list, x, 4, AVP_Service_Identifier, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); // Rating Group = -1 => omit Rating group if (active_rating_group >= 0) { set_4bytes(x, active_rating_group); Ro_add_avp_list(&mscc_list, x, 4, AVP_Rating_Group, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); } /* if we must Used-Service-Unit */ if (used_unit >= 0) { set_4bytes(x, used_unit); Ro_add_avp_list(&used_list, x, 4, AVP_CC_Time, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); used_group = cdpb.AAAGroupAVPS(used_list); cdpb.AAAFreeAVPList(&used_list); Ro_add_avp_list(&mscc_list, used_group.s, used_group.len, AVP_Used_Service_Unit, AAA_AVP_FLAG_MANDATORY, 0, AVP_FREE_DATA, __FUNCTION__); } group = cdpb.AAAGroupAVPS(mscc_list); cdpb.AAAFreeAVPList(&mscc_list); return Ro_add_avp(msg, group.s, group.len, AVP_Multiple_Services_Credit_Control, AAA_AVP_FLAG_MANDATORY, 0, AVP_FREE_DATA, __FUNCTION__); }
void Send_ASA(cdp_session_t* s, AAAMessage* msg) { AAAMessage *asa; char x[4]; AAA_AVP *avp; LOG(L_INFO,"Send_ASA(): sending ASA\n"); if (!s) { //send an ASA for UNKNOWN_SESSION_ID - use AAASendMessage() // msg is the ASR received asa = AAANewMessage(IMS_ASA,0,0,msg); if (!asa) return; set_4bytes(x,AAA_SUCCESS); AAACreateAndAddAVPToMessage(asa,AVP_Result_Code,AAA_AVP_FLAG_MANDATORY,0,x,4); AAASendMessage(asa,0,0); }else{ // send... many cases... maybe not needed. // for now we do the same asa = AAANewMessage(IMS_ASA,0,0,msg); if (!asa) return; set_4bytes(x,AAA_SUCCESS); AAACreateAndAddAVPToMessage(asa,AVP_Result_Code,AAA_AVP_FLAG_MANDATORY,0,x,4); avp = AAAFindMatchingAVP(msg,0,AVP_Origin_Host,0,0); if (avp) { // This is because AAASendMessage is not going to find a route to the // the PCRF because TS 29.214 says no Destination-Host and no Auth-Application-Id // in the ASA LOG(L_INFO,"sending ASA to peer %.*s\n",avp->data.len,avp->data.s); peer *p; p = get_peer_by_fqdn(&avp->data); if (!peer_send_msg(p,asa)) { if (asa) AAAFreeMessage(&asa); //needed in frequency } else LOG(L_INFO,"success sending ASA\n"); }else if (!AAASendMessage(asa,0,0)) { LOG(L_ERR,"Send_ASA() : error sending ASA\n"); } } }
/* called only when building stop record AVPS */ inline int Ro_add_multiple_service_credit_Control_stop(AAAMessage *msg, int used_unit, int active_rating_group, int active_service_identifier) { char x[4]; AAA_AVP_LIST used_list, mscc_list; str used_group; // Add Multiple-Services AVP Indicator set_4bytes(x, 1); Ro_add_avp(msg, x, 4, AVP_Multiple_Services_Indicator, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); //unsigned int service_id = 1000; //Removed these are now configurable config file params //unsigned int rating_group = 500; //Removed these are now configurable config file params used_list.head = 0; used_list.tail = 0; mscc_list.head = 0; mscc_list.tail = 0; /* if we must Used-Service-Unit */ if (used_unit >= 0) { set_4bytes(x, used_unit); Ro_add_avp_list(&used_list, x, 4, AVP_CC_Time, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); used_group = cdpb.AAAGroupAVPS(used_list); cdpb.AAAFreeAVPList(&used_list); Ro_add_avp_list(&mscc_list, used_group.s, used_group.len, AVP_Used_Service_Unit, AAA_AVP_FLAG_MANDATORY, 0, AVP_FREE_DATA, __FUNCTION__); } set_4bytes(x, active_service_identifier); Ro_add_avp_list(&mscc_list, x, 4, AVP_Service_Identifier, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); // Rating Group = -1 => omit Rating group if (active_rating_group >= 0) { set_4bytes(x, active_rating_group); Ro_add_avp_list(&mscc_list, x, 4, AVP_Rating_Group, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); } used_group = cdpb.AAAGroupAVPS(mscc_list); cdpb.AAAFreeAVPList(&mscc_list); return Ro_add_avp(msg, used_group.s, used_group.len, AVP_Multiple_Services_Credit_Control, AAA_AVP_FLAG_MANDATORY, 0, AVP_FREE_DATA, __FUNCTION__); }
/** * Adds the Applications to a Capability Exchange message. * \note Must be called with a lock on the peer. * @param msg - the message to add to (request/answer) * @param p - the peer to add applications from */ static inline void Snd_CE_add_applications(AAAMessage *msg,peer *p) { int i; app_config *app; char x[4]; AAA_AVP *avp1,*avp2; AAA_AVP_LIST list; str group; list.head=0;list.tail=0; for(i=0;i<config->applications_cnt;i++){ app = config->applications+i; if (app->vendor==0){ set_4bytes(x,app->id); AAACreateAndAddAVPToMessage(msg, (app->type==DP_AUTHORIZATION?AVP_Auth_Application_Id:AVP_Acct_Application_Id), AAA_AVP_FLAG_MANDATORY,0,x,4); }else{ set_4bytes(x,app->vendor); avp1 = AAACreateAVP(AVP_Vendor_Id,AAA_AVP_FLAG_MANDATORY,0,x,4, AVP_DUPLICATE_DATA); AAAAddAVPToList(&list,avp1); set_4bytes(x,app->id); avp2 = AAACreateAVP((app->type==DP_AUTHORIZATION?AVP_Auth_Application_Id:AVP_Acct_Application_Id), AAA_AVP_FLAG_MANDATORY,0,x,4,AVP_DUPLICATE_DATA); AAAAddAVPToList(&list,avp2); group = AAAGroupAVPS(list); AAAFreeAVPList(&list); AAACreateAndAddAVPToMessage(msg, AVP_Vendor_Specific_Application_Id, AAA_AVP_FLAG_MANDATORY,0,group.s,group.len); shm_free(group.s); } } for(i=0;i<config->supported_vendors_cnt;i++){ set_4bytes(x,config->supported_vendors[i]); AAACreateAndAddAVPToMessage(msg,AVP_Supported_Vendor_Id,AAA_AVP_FLAG_MANDATORY,0,x,4); } }
/** * Creates and adds a Result-Code AVP. * @param msg - the Diameter message to add to. * @param data - the value for the AVP payload * @returns 1 on success or 0 on error */ inline int cxdx_add_result_code(AAAMessage *msg,unsigned int data) { char x[4]; set_4bytes(x,data); return cxdx_add_avp(msg,x,4, AVP_Result_Code, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); }
/** * Creates and adds a Auth-Session-State AVP. * @param msg - the Diameter message to add to. * @param data - the value for the AVP payload * @returns 1 on success or 0 on error */ inline int cxdx_add_auth_session_state(AAAMessage *msg,unsigned int data) { char x[4]; set_4bytes(x,data); return cxdx_add_avp(msg,x,4, AVP_Auth_Session_State, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); }
/** * Creates and adds a SIP-Number-Auth-Items AVP. * @param msg - the Diameter message to add to. * @param data - the value for the AVP payload * @returns 1 on success or 0 on error */ inline int cxdx_add_sip_number_auth_items(AAAMessage *msg,unsigned int data) { char x[4]; set_4bytes(x,data); return cxdx_add_avp(msg,x,4, AVP_IMS_SIP_Number_Auth_Items, AAA_AVP_FLAG_MANDATORY|AAA_AVP_FLAG_VENDOR_SPECIFIC, IMS_vendor_id_3GPP, AVP_DUPLICATE_DATA, __FUNCTION__); }
/** * Creates and adds a Server-Assignment-Type AVP. * @param msg - the Diameter message to add to. * @param data - the value for the AVP payload * @returns 1 on success or 0 on error */ inline int cxdx_add_server_assignment_type(AAAMessage *msg,unsigned int data) { char x[4]; set_4bytes(x,data); return cxdx_add_avp(msg,x,4, AVP_IMS_Server_Assignment_Type, AAA_AVP_FLAG_MANDATORY|AAA_AVP_FLAG_VENDOR_SPECIFIC, IMS_vendor_id_3GPP, AVP_DUPLICATE_DATA, __FUNCTION__); }
/** * Creates and adds Userdata-Available AVP. * @param msg - the Diameter message to add to. * @param data - the value for the AVP payload * @returns 1 on success or 0 on error */ inline int cxdx_add_userdata_available(AAAMessage *msg,unsigned int data) { char x[4]; set_4bytes(x,data); return cxdx_add_avp(msg,x,4, AVP_IMS_User_Data_Already_Available, AAA_AVP_FLAG_MANDATORY|AAA_AVP_FLAG_VENDOR_SPECIFIC, IMS_vendor_id_3GPP, AVP_DUPLICATE_DATA, __FUNCTION__); }
/** * Creates and adds a Authorization-Type AVP. * @param msg - the Diameter message to add to. * @param data - the value for the AVP payload * @returns 1 on success or 0 on error */ inline int Cx_add_authorization_type(AAAMessage *msg,unsigned int data) { char x[4]; set_4bytes(x,data); return Cx_add_avp(msg,x,4, AVP_IMS_User_Authorization_Type, AAA_AVP_FLAG_MANDATORY|AAA_AVP_FLAG_VENDOR_SPECIFIC, IMS_vendor_id_3GPP, AVP_DUPLICATE_DATA, __FUNCTION__); }
/** * Creates and adds a perMbyte_credit AVP. * @param msg - the Diameter message to add to. * @param data - the value for the AVP payload * @returns 1 on success or 0 on error */ inline int Rf_add_Credit_perMbyte(AAAMessage *msg, unsigned int data) { char x[4]; set_4bytes(x,data); return Rf_add_avp(msg,x,4, AVP_Credit_perMbyte, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); }
/** * Creates and adds an Acct-Application-Id AVP. * @param msg - the Diameter message to add to. * @param data - the value for the AVP payload * @return 1 on success or 0 on error */ inline int Gq_add_auth_application_id(AAAMessage *msg, unsigned int data) { char x[4]; set_4bytes(x, data); return Gq_add_avp(msg, x, 4, AVP_Auth_Application_Id, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); }
/** * Creates and adds a Accounting-Number-Type AVP. * @param msg - the Diameter message to add to. * @param data - the value for the AVP payload * @returns 1 on success or 0 on error * * TODO should be added by base protocol */ inline int Rf_add_accounting_record_number(AAAMessage* msg, unsigned int data) { char x[4]; set_4bytes(x,data); return Rf_add_avp(msg, x, 4, AVP_Accounting_Record_Number, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); }
/** * Creates and adds a Experimental-Result-Code AVP. * @param msg - the Diameter message to add to. * @param data - the value for the AVP payload * @returns 1 on success or 0 on error */ inline int Cx_add_experimental_result_code(AAAMessage *msg,unsigned int data) { AAA_AVP_LIST list; str group; char x[4]; list.head=0;list.tail=0; set_4bytes(x,data); Cx_add_avp_list(&list, x,4, AVP_IMS_Experimental_Result_Code, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); set_4bytes(x,IMS_vendor_id_3GPP); Cx_add_avp_list(&list, x,4, AVP_IMS_Vendor_Id, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__); group = cdpb.AAAGroupAVPS(list); cdpb.AAAFreeAVPList(&list); return Cx_add_avp(msg,group.s,group.len, AVP_IMS_Experimental_Result, AAA_AVP_FLAG_MANDATORY, 0, AVP_FREE_DATA, __FUNCTION__); }
/** * Add Session-Timeout, Auth-Lifetime and Auth-Grace-Period AVPs to outgoing messages in case they are missing * @param x * @param msg */ void add_auth_session_timers(cdp_auth_session_t *x,AAAMessage *msg) { AAA_AVP *avp; char data[4]; uint32_t v; avp = AAAFindMatchingAVP(msg,0,AVP_Authorization_Lifetime,0,0); if (!avp){ if (x->lifetime==-1) v=0xFFFFFFFF; else { v = x->lifetime-time(0); if (v<0) v = 0; } set_4bytes(data,v); avp = AAACreateAVP(AVP_Authorization_Lifetime,AAA_AVP_FLAG_MANDATORY,0,data,4,AVP_DUPLICATE_DATA); if (avp) AAAAddAVPToMessage(msg,avp,0); } if (x->lifetime!=-1){ avp = AAAFindMatchingAVP(msg,0,AVP_Auth_Grace_Period,0,0); if (!avp){ v = x->grace_period; set_4bytes(data,v); avp = AAACreateAVP(AVP_Auth_Grace_Period,AAA_AVP_FLAG_MANDATORY,0,data,4,AVP_DUPLICATE_DATA); if (avp) AAAAddAVPToMessage(msg,avp,0); } } avp = AAAFindMatchingAVP(msg,0,AVP_Session_Timeout,0,0); if (!avp){ if (x->timeout==-1) v=0xFFFFFFFF; else { v = x->timeout-time(0); if (v<0) v = 0; } set_4bytes(data,v); avp = AAACreateAVP(AVP_Session_Timeout,AAA_AVP_FLAG_MANDATORY,0,data,4,AVP_DUPLICATE_DATA); if (avp) AAAAddAVPToMessage(msg,avp,0); } }
int add_vendor_specific_application_id_group(AAAMessage * msg, unsigned int vendor_id, unsigned int auth_app_id) { char x[4]; AAA_AVP_LIST list_grp = {0, 0}; AAA_AVP *avp; str group = {0, 0}; set_4bytes(x, vendor_id); if (!(avp = AAACreateAVP(AVP_Vendor_Id, AAA_AVP_FLAG_MANDATORY, 0, x, 4, AVP_DUPLICATE_DATA))) goto error; AAAAddAVPToList(&list_grp, avp); set_4bytes(x, auth_app_id); if (!(avp = AAACreateAVP(AVP_Auth_Application_Id, AAA_AVP_FLAG_MANDATORY, 0, x, 4, AVP_DUPLICATE_DATA))) goto error; AAAAddAVPToList(&list_grp, avp); group = AAAGroupAVPS(list_grp); if (!group.s || !group.len) goto error; if (!(avp = AAACreateAVP(AVP_Vendor_Specific_Application_Id, AAA_AVP_FLAG_MANDATORY, 0, group.s, group.len, AVP_DUPLICATE_DATA))) goto error; if (AAAAddAVPToMessage(msg, avp, msg->avpList.tail) != AAA_ERR_SUCCESS) goto error; AAAFreeAVPList(&list_grp); shm_free(group.s); group.s = NULL; return 1; error: AAAFreeAVPList(&list_grp); if (group.s) shm_free(group.s); return 0; }
/** * Creates and adds Expires AVP to an AVP list * @param list - the AVP list to add to. * @param data - the value for the AVP payload. * @return 1 on successs or 0 on error */ inline int Rf_add_expires(AAA_AVP_LIST* list, unsigned int data) { char x[4]; set_4bytes(x, data); return Rf_add_avp_list(list, x,4, AVP_IMS_Expires, AAA_AVP_FLAG_MANDATORY, IMS_vendor_id_3GPP, AVP_DUPLICATE_DATA, __FUNCTION__); }
/** * Sends a Diameter Watch-dog Answer. * \note Must be called with a lock on the peer. * @param p - the peer that the DWR was received from * @param dwr - the DWR message * @param result_code - the Result-Code to attach to DWA * @param sock - socket to send on */ void Snd_DWA(peer *p,AAAMessage *dwr,int result_code,int sock) { AAAMessage *dwa; char x[4]; dwa = AAANewMessage(Code_DW,0,0,dwr); if (!dwa) goto done; set_4bytes(x,result_code); AAACreateAndAddAVPToMessage(dwa,AVP_Result_Code,AAA_AVP_FLAG_MANDATORY,0,x,4); peer_send_msg(p,dwa); done: AAAFreeMessage(&dwr); }