/*++ Copyright (c) 1990 Microsoft Corporation Module Name: nmsmsgf.c Abstract: This module contains the functions for formatting and unformatting the various messages that are sent and/or received from nbt nodes. It also contains the function called by the NBT threads to service a name request Functions: NmsMsgfProcNbtReq GetName GetOtherInfo NmsMsgfFrmNamRspMsg FrmNamRegRsp FrmNamRelRsp FrmNamQueryRsp FormatQueryRspBuff FormatName NmsMsgfFrmNamQueryReq NmsMsgfFrmNamRelReq NmsMsgfFrmWACK NmsMsgfUfmNamRsp Author: Pradeep Bahl (PradeepB) Dec-1992 Revision History: --*/ /* Includes */ #include "wins.h" #include "nms.h" #include "nmsdb.h" #include "winsevt.h" #include "winscnf.h" #include "winsmsc.h" #include "nmsmsgf.h" #include "nmsnmh.h" #include "nmschl.h" #include "comm.h" #include "winsintf.h" /* defines */ #define NAME_HEADER_SIZE 12 /* header size (bytes before the Ques * name section of a name packet */ #define NAME_FORMAT_MASK 0xC0 /*top two bits of a byte*/ #define NODE_TYPE_MASK 0x60 /*bit 13 and 14 of NBFLAGs field */ #define SHIFT_NODE_BITS 5 //shift the node bits in the byte //containing them by this amount #define LENGTH_MASK 0x3F /*6 LSBs of the top byte of the * QuesNamSec field */ #define GROUP_BIT_MASK 0x80 /*bit 7 of the 1st byte (MSB)of the *16 bit NBFLAGS field */ /* * Max length of a Name (including label length octets) in RFC packet */ #define RFC_MAX_NAM_LEN 255 // // Max size of internal name as derived from the rfc packet name // #define MAX_SIZE_INTERNAL_NAME (RFC_MAX_NAM_LEN - 16) //This should be = (255 - 16) //since the max size of the netbios //name (with scope attached) can be //be 255. The first 32 bytes //are encoded. These map to 16 //bytes in the internal name /* * Max length of a label in a name */ #define RFC_MAX_LABEL_LEN 63 /* * Sizes of the various fields in the name service packets received or sent * by the WINS server. These sizes are specified in RFC 1002 */ #define RFC_LEN_QTYP (2) #define RFC_LEN_QCLS (2) #define RFC_LEN_TTL (4) #define RFC_LEN_RDLEN (2) #define RFC_LEN_NBFLAGS (2) #define RFC_LEN_NBADD (4) #define RFC_LEN_RRTYP (2) #define RFC_LEN_RRCLS (2) #define RFC_LEN_RRPTR (2) #define RFC_LEN_QTYP_N_QCLS (RFC_LEN_QTYP + RFC_LEN_QCLS) /* page 10 - *RFC 1002 */ #define RFC_LEN_RRTYP_N_RRCLS (RFC_LEN_RRTYP + RFC_LEN_RRCLS) /* page 11 - *RFC 1002 */ /* * The following is used by FrmNamQueryRsp in its calculation to determine * if the name query buffer would be big enough for the response */ #define RFC_LEN_TTL_N_RDLEN (RFC_LEN_TTL + RFC_LEN_RDLEN) #define RFC_LEN_RR_N_TTL (RFC_LEN_RRTYP_N_RRCLS + RFC_LEN_TTL) #define RFC_LEN_RR_N_TTL_N_RDLEN_N_NBF (RFC_LEN_RR_N_TTL + \ RFC_LEN_RDLEN + RFC_LEN_NBFLAGS) // // Length of NBFLAGS and the NB address // #define RFC_LEN_NBF_N_NBA (RFC_LEN_NBFLAGS + RFC_LEN_NBADD) #define RFC_LEN_RDLEN_N_NBF (RFC_LEN_RDLEN + RFC_LEN_NBFLAGS) // // Length of the RDLEN, NB flags and NB address section. Page 13 of RFC 1002 // #define RFC_LEN_RDLEN_N_NBF_N_NBA (RFC_LEN_RDLEN + RFC_LEN_NBF_N_NBA) /* * Size of the TTL, RDLEN, NB Flags and NB address section */ #define RFC_LEN_TTL_N_RDLEN_N_NBF_N_NBA (RFC_LEN_TTL + RFC_LEN_RDLEN_N_NBF_N_NBA) /* The value of the 3rd and 4 th byte of the first long of the response packets for the different name requests. The bytes are numbered from the start of the pkt. Note: for a negative response the Rcode value (4 LSBs of the 4th byte of the message) has to be ORed with the LBFW values */ #define RFC_NAM_REG_RSP_OPC (0xAD) /*+ve registration response*/ #define RFC_NAM_REG_RSP_4THB (0x80) /*4th byte of the above pkt */ #define RFC_NAM_REL_RSP_OPC (0xB4) /*+ve release response*/ #define RFC_NAM_REL_RSP_4THB (0x00) /*4th byte of the above pkt*/ #define RFC_NAM_QUERY_RSP_OPC_NO_T (0x85) /*+ve query resp (complete)*/ #define RFC_NAM_QUERY_RSP_OPC_T (0x87) /*+ve query resp (truncated)*/ #define RFC_NAM_QUERY_RSP_4THB (0x80) /*4th byte of the above pkt */ /* * Values of different fields in RFC response packet */ /* QD Count and AN count fields of the Name Reg. Rsp pkt */ #define RFC_NAM_REG_RSP_QDCNT_1STB (0x00) #define RFC_NAM_REG_RSP_QDCNT_2NDB (0x00) #define RFC_NAM_REG_RSP_ANCNT_1STB (0x00) #define RFC_NAM_REG_RSP_ANCNT_2NDB (0x01) /* NS Count and AR count fields of the Name Reg. Rsp pkt */ #define RFC_NAM_REG_RSP_NSCNT_1STB (0x00) #define RFC_NAM_REG_RSP_NSCNT_2NDB (0x00) #define RFC_NAM_REG_RSP_ARCNT_1STB (0x00) #define RFC_NAM_REG_RSP_ARCNT_2NDB (0x00) /* QD Count and AN count fields of the Name Rel. Rsp pkt */ #define RFC_NAM_REL_RSP_QDCNT_1STB (0x00) #define RFC_NAM_REL_RSP_QDCNT_2NDB (0x00) #define RFC_NAM_REL_RSP_ANCNT_1STB (0x00) #define RFC_NAM_REL_RSP_ANCNT_2NDB (0x01) /* NS Count and AR count fields of the Name Rel. Rsp pkt */ #define RFC_NAM_REL_RSP_NSCNT_1STB (0x00) #define RFC_NAM_REL_RSP_NSCNT_2NDB (0x00) #define RFC_NAM_REL_RSP_ARCNT_1STB (0x00) #define RFC_NAM_REL_RSP_ARCNT_2NDB (0x00) /* QD Count and AN count fields of the Name Query. Rsp pkt */ #define RFC_NAM_QUERY_RSP_QDCNT_1STB (0x00) #define RFC_NAM_QUERY_RSP_QDCNT_2NDB (0x00) #define RFC_NAM_QUERY_RSP_ANCNT_1STB (0x00) #define RFC_NAM_QUERY_POS_RSP_ANCNT_2NDB (0x01) #define RFC_NAM_QUERY_NEG_RSP_ANCNT_2NDB (0x00) /* NS Count and AR count fields of the Name Query. Rsp pkt */ #define RFC_NAM_QUERY_RSP_NSCNT_1STB (0x00) #define RFC_NAM_QUERY_RSP_NSCNT_2NDB (0x00) #define RFC_NAM_QUERY_RSP_ARCNT_1STB (0x00) #define RFC_NAM_QUERY_RSP_ARCNT_2NDB (0x00) /* * NB and IN fields of the name query response pkt * Page 21 and 22 of RFC 1002 */ /* Positive name query response */ #define RFC_NAM_QUERY_POS_RSP_NB_1STB (0x00) #define RFC_NAM_QUERY_POS_RSP_NB_2NDB (0x20) #define RFC_NAM_QUERY_POS_RSP_IN_1STB (0x00) #define RFC_NAM_QUERY_POS_RSP_IN_2NDB (0x01) /* Negative name query response */ #define RFC_NAM_QUERY_NEG_RSP_NB_1STB (0x00) #define RFC_NAM_QUERY_NEG_RSP_NB_2NDB (0x0A) #define RFC_NAM_QUERY_NEG_RSP_IN_1STB (0x00) #define RFC_NAM_QUERY_NEG_RSP_IN_2NDB (0x01) /* name query request opcode byte and 4th byte */ #define RFC_NAM_QUERY_REQ_OPCB (0x01) #define RFC_NAM_QUERY_REQ_4THB (0x0) /* name query request QDCOUNT and ANCOUNT bytes */ #define RFC_NAM_QUERY_REQ_QDCNT_1STB (0x00) #define RFC_NAM_QUERY_REQ_QDCNT_2NDB (0x01) #define RFC_NAM_QUERY_REQ_ANCNT_1STB (0x00) #define RFC_NAM_QUERY_REQ_ANCNT_2NDB (0x00) /* name query request NSCOUNT and ARCOUNT bytes */ #define RFC_NAM_QUERY_REQ_NSCNT_1STB (0x00) #define RFC_NAM_QUERY_REQ_NSCNT_2NDB (0x00) #define RFC_NAM_QUERY_REQ_ARCNT_1STB (0x00) #define RFC_NAM_QUERY_REQ_ARCNT_2NDB (0x00) /* name query request QTYP and QCLS bytes */ #define RFC_NAM_QUERY_REQ_QTYP_1STB (0x00) #define RFC_NAM_QUERY_REQ_QTYP_2NDB (0x20) #define RFC_NAM_QUERY_REQ_QCLS_1STB (0x00) #define RFC_NAM_QUERY_REQ_QCLS_2NDB (0x01) /* name release request opcode byte and 4th byte */ #define RFC_NAM_REL_REQ_OPCB (0x30) #define RFC_NAM_REL_REQ_4THB (0x00) /* name release request QDCOUNT and ANCOUNT bytes */ #define RFC_NAM_REL_REQ_QDCNT_1STB (0x00) #define RFC_NAM_REL_REQ_QDCNT_2NDB (0x01) #define RFC_NAM_REL_REQ_ANCNT_1STB (0x00) #define RFC_NAM_REL_REQ_ANCNT_2NDB (0x00) /* name release request NSCOUNT and ARCOUNT bytes */ #define RFC_NAM_REL_REQ_NSCNT_1STB (0x00) #define RFC_NAM_REL_REQ_NSCNT_2NDB (0x00) #define RFC_NAM_REL_REQ_ARCNT_1STB (0x00) #define RFC_NAM_REL_REQ_ARCNT_2NDB (0x01) /* name release request QTYP and QCLS bytes */ #define RFC_NAM_REL_REQ_QTYP_1STB (0x00) #define RFC_NAM_REL_REQ_QTYP_2NDB (0x20) #define RFC_NAM_REL_REQ_QCLS_1STB (0x00) #define RFC_NAM_REL_REQ_QCLS_2NDB (0x01) /* name Release request RRTYP and RRCLS bytes */ #define RFC_NAM_REL_REQ_RRTYP_1STB (0x00) #define RFC_NAM_REL_REQ_RRTYP_2NDB (0x20) #define RFC_NAM_REL_REQ_RRCLS_1STB (0x00) #define RFC_NAM_REL_REQ_RRCLS_2NDB (0x01) /* WACK opcode byte and 4th byte */ #define RFC_WACK_OPCB (0xBC) #define RFC_WACK_4THB (0x0) /* WACK QDCOUNT and ANCOUNT bytes */ #define RFC_WACK_QDCNT_1STB (0x0) #define RFC_WACK_QDCNT_2NDB (0x0) #define RFC_WACK_ANCNT_1STB (0x0) #define RFC_WACK_ANCNT_2NDB (0x1) /* WACK NSCOUNT and ARCOUNT bytes */ #define RFC_WACK_NSCNT_1STB (0x0) #define RFC_WACK_NSCNT_2NDB (0x0) #define RFC_WACK_ARCNT_1STB (0x0) #define RFC_WACK_ARCNT_2NDB (0x0) /* WACK RRTYP and RRCLS bytes */ #define RFC_WACK_RRTYP_1STB (0x00) #define RFC_WACK_RRTYP_2NDB (0x20) #define RFC_WACK_RRCLS_1STB (0x00) #define RFC_WACK_RRCLS_2NDB (0x01) // WACK RDLENGTH Field #define RFC_WACK_RDLENGTH_1STB (0x0) #define RFC_WACK_RDLENGTH_2NDB (0x02) /* Local variable declarations */ /* Local function declarations */ /* *GetName -- Extract name out of packet */ STATIC VOID GetName( IN OUT LPBYTE *ppName, IN OUT LPBYTE pName, OUT LPDWORD pNameLen ); /* * Format Name - Format (encode) name for placing in RFC packet */ STATIC VOID FormatName( IN LPBYTE pNameToFormat, IN DWORD LengthOfName, IN OUT LPBYTE *ppFormattedName ); /* * GetOtherInfo -- Get information (excluding the name) from the pkt */ STATIC STATUS GetOtherInfo( IN NMSMSGF_NAM_REQ_TYP_E Opcode_e, IN LPBYTE pRR, /*point to the RR_NAME section in the *name registration packet */ IN INT QuesNamSecLen, //Size of Ques name section OUT LPBOOL pfGrp, //Flag -- unique/group entry OUT PNMSMSGF_CNT_ADD_T pCntAdd, //Address OUT PNMSMSGF_NODE_TYP_E pNodeTyp_e //Node Type if unique ); /* * FrmNamRegRsp - Format name registration response */ STATIC STATUS FrmNamRegRsp( PCOMM_HDL_T pDlgHdl, PNMSMSGF_RSP_INFO_T pRspInfo ); /* * FrmNamRelRsp - Format name release response */ STATIC STATUS FrmNamRelRsp( PCOMM_HDL_T pDlgHdl, PNMSMSGF_RSP_INFO_T pRspInfo ); #if 0 /* * FrmNamQueryRsp - Format name query response */ STATIC STATUS FrmNamQueryRsp( IN PCOMM_HDL_T pDlgHdl, PNMSMSGF_RSP_INFO_T pRspInfo ); #endif /* * FormatQueryRspBuff - Format name query response buffer */ STATIC STATUS FormatQueryRspBuff( IN LPBYTE pDest, IN LPBYTE pSrc, IN PNMSMSGF_RSP_INFO_T pRspInfo, IN BOOL fTrunc ); /* function definitions */ STATUS NmsMsgfProcNbtReq( PCOMM_HDL_T pDlgHdl, MSG_T pMsg, MSG_LEN_T MsgLen ) /*++ Routine Description: This function is called by an nbt request thread after it dequeues an nbt request message from the work-queue. The function unformats the message and then calls the appropriate function to process it. Arguments: pDlgHdl - Dlg Handle pMsg - Message Buffer (contains that RFC packet containing the request received from an NBT node) MsgLen - Length of above buffer Externals Used: None Called by: NbtThdInitFn() in nms.c Comments: None Return Value: Success status codes -- WINS_SUCCESS Error status codes -- WINS_FAILURE --*/ { NMSMSGF_NAM_REQ_TYP_E Opcode; BYTE Name[NMSDB_MAX_NAM_LEN]; DWORD NameLen; /*length of name */ DWORD QuesNamSecLen; /*length of question *name section in *packet */ NMSMSGF_NODE_TYP_E NodeTyp_e = NMSMSGF_E_PNODE; // BOOL fRefresh; NMSMSGF_CNT_ADD_T CntAdd; COMM_ADD_T Address; BOOL fGrp; /*flag indicating whether the name *is a Unique/Group Netbios name. *fGrp is TRUE if the name is a *group name, else it is FALSE */ BOOL fBuffFreed = FALSE; //indicates whether buffer has //been freed or not LPBYTE pTmp = (LPBYTE)pMsg; LPBYTE pTmp2; DBGENTER("NmsMsgfProcNbtReq\n"); try { // get the opcode Opcode = (NMS_OPCODE_MASK & *(pTmp + 2)) >> 3; #ifdef JIM { BYTE TransId = *pTmp; ASSERT(TransId == 0x80); } #endif /* * make pTmp point to the Question Section. All name request * packets have a name header of standard size (RFC 1002) at the top */ pTmp += NAME_HEADER_SIZE; /* * Extract the name ind store in Name. GetName will update pTmp to * point just beyond the name in the question section */ pTmp2 = pTmp; /*save pTmp so that when GetName returns we can * determine the length of the question name section */ GetName( &pTmp, Name, &NameLen ); QuesNamSecLen = (ULONG) (pTmp - pTmp2); pTmp += RFC_LEN_QTYP_N_QCLS; /* skip past the ques. type and ques. * class fields We don't need to examine * these. The question type field * will always be NB and question class *field will always be INTERNET */ #ifdef TESTWITHUB // // Check if the broadcast bit is set. If yes, drop the pkt. // if (*(pMsg + 3) & 0x10) { DBGPRINT2(SPEC, "Broadcast pkt BEING DROPPED; name is (%s). Opcode is (%d)\n", Name, Opcode); #if 0 printf("Broadcast pkt BEING DROPPED; name is (%s). Opcode is (%d)\n", Name, Opcode); #endif ECommFreeBuff(pMsg); ECommEndDlg(pDlgHdl); return(WINS_SUCCESS); } #endif // // Let us set the flag to TRUE. If any of the following called // functions raises an exception, then it is a requirement that // it does so only after freeing the buffer (i.e. it must catch // all exceptions, free the buffer and then reraise the // exception - if it wants) // fBuffFreed = TRUE; // // If the 16th character is a 1B switch it with the 1st character. // This is done to support Browsing. Browsers want a list of all // names with 16th character being 1B. Putting 1B as the // 1st character enables WINS to find all 1B names quickly. // NMSMSGF_MODIFY_NAME_IF_REQD_M(Name); /* * Switch on the type of request as determined by the Opcode */ switch(Opcode) { /* name registration and refresh are handled the same way */ case(NMSMSGF_E_NAM_REF): case(NMSMSGF_E_NAM_REF_UB): DBGPRINT0(FLOW, "It is a name refresh request\n"); case(NMSMSGF_E_NAM_REG): /* fall through */ case(NMSMSGF_E_MULTIH_REG): /* fall through */ /* * Get the flag indicating whether the request is a group * registration or a unique name registration. The IP * address(es) is (are) also retrieved */ GetOtherInfo( Opcode, pTmp, QuesNamSecLen, &fGrp, &CntAdd, &NodeTyp_e ); // // If it is not a group or a multihomed registration or // if (!fGrp && (Opcode != NMSMSGF_E_MULTIH_REG)) { /* * Register the unique name */ NmsNmhNamRegInd( pDlgHdl, Name, NameLen, CntAdd.Add, (BYTE)NodeTyp_e, pMsg, MsgLen, QuesNamSecLen, Opcode == NMSMSGF_E_NAM_REG ? FALSE : TRUE, NMSDB_ENTRY_IS_NOT_STATIC, FALSE //is it admin flag ? ); } else //it is a group or is mutihomed { /* * Register the group name */ NmsNmhNamRegGrp( pDlgHdl, Name, NameLen, &CntAdd, (BYTE)NodeTyp_e, pMsg, MsgLen, QuesNamSecLen, fGrp ? NMSDB_NORM_GRP_ENTRY : (Opcode == NMSMSGF_E_MULTIH_REG) ? NMSDB_MULTIHOMED_ENTRY : NMSDB_NORM_GRP_ENTRY, //passing NMSDB_NORM_GRP_ENTRY for spec. grp is fine //see NmsNmhNamRegGrp() Opcode == NMSMSGF_E_NAM_REG ? FALSE : TRUE, NMSDB_ENTRY_IS_NOT_STATIC, FALSE //is it admin ? ); } break; case(NMSMSGF_E_NAM_QUERY): #if 0 Address.AddTyp_e = COMM_ADD_E_TCPUDPIP; Address.AddLen = sizeof(COMM_IP_ADD_T); COMM_GET_IPADD_M(pDlgHdl, &Address.Add.IPAdd); #endif #if 0 // // NOTE: Multiple NBT threads could be doing this simultaneously // // This is the best I can do without a critical section // FUTURES("The count may not be correct when retrieved by an RPC thread") WinsIntfStat.Counters.NoOfQueries++; #endif /* Query the name */ NmsNmhNamQuery( pDlgHdl, Name, NameLen, pMsg, MsgLen, QuesNamSecLen, FALSE, // is it admin flag NULL //should be non NULL only in //an RPC thread ); break; case(NMSMSGF_E_NAM_REL): GetOtherInfo( NMSMSGF_E_NAM_REL, pTmp, QuesNamSecLen, &fGrp, &CntAdd, &NodeTyp_e ); // // We should pass down to NmsNmhNamRel function the // address of the client requesting name release, not // the address passed in the RFC pkt. The address // will be used by NmsDbRelRow to check if the client // is authorized to release the record // Address.AddTyp_e = COMM_ADD_E_TCPUDPIP; Address.AddLen = sizeof(COMM_IP_ADD_T); COMM_GET_IPADD_M(pDlgHdl, &Address.Add.IPAdd); /* * Release the name */ NmsNmhNamRel( pDlgHdl, Name, NameLen, &Address, fGrp, pMsg, MsgLen, QuesNamSecLen, FALSE //is it admin flag ? ); break; default: fBuffFreed = FALSE; DBGPRINT1(EXC, "NmsMsgfProcNbtReq: Invalid Opcode\n", Opcode); WINS_RAISE_EXC_M(WINS_EXC_PKT_FORMAT_ERR); WINSEVT_LOG_M(Opcode, WINS_EVT_INVALID_OPCODE); break; } } except(EXCEPTION_EXECUTE_HANDLER) { DBGPRINTEXC("NmsMsgfProcNbtReq"); if (GetExceptionCode() == WINS_EXC_NBT_ERR) { WINS_RERAISE_EXC_M(); } // // Free the message buffer if not already freed, delete the // dialogue if it is a UDP dialogue. // if (!fBuffFreed) { ECommFreeBuff(pMsg); ECommEndDlg(pDlgHdl); } } DBGLEAVE("NmsMsgfProcNbtReq\n"); return(WINS_SUCCESS); } VOID GetName( IN OUT LPBYTE *ppName, IN OUT LPBYTE pName, OUT LPDWORD pNameLen ) /*++ Routine Description: This function is called to retrieve the name from the name request packet. Arguments: ppName -- address of ptr to question section in datagram received pName -- Address of array to hold the name. It is assumed that this is atleast NMSMSGF_RFC_MAX_NAM_LEN long. pNameLen -- address of variable to hold length of name Externals Used: None Called by: NmsNmhProcNbtReq Comments: None Return Value: None --*/ { INT HighTwoBits; //First two bits of Question Name section INT Length; //length of label in Question Name section BYTE ch; LPBYTE pNmInPkt = *ppName; INT inLen = NMSMSGF_RFC_MAX_NAM_LEN; // Store the length of the name. *pNameLen = 0; /* Get the high two bits of the first byte of the Question_NAME section. The bits have to be 00. If they are not, something is really wrong. */ if ((HighTwoBits = (NAME_FORMAT_MASK & *pNmInPkt)) != 0) { goto BadFormat; } /* * Get the length of the label. Length, extracted this way, is * guranteed to be <= 63. */ Length = LENGTH_MASK & *pNmInPkt; pNmInPkt++; //increment past the length byte /* * Decode the first label of the name (the netbios name without the * scope). */ while(Length > 0 ) { ch = *pNmInPkt++ - 'A'; *pName++ = (ch << 4) | (*pNmInPkt++ - 'A'); (*pNameLen)++; Length -= 2; } inLen -= Length; /* Extract the netbios scope if present The netbios scope is not in encoded form */ while(TRUE) { /* * if length byte is not 0, there is a netbios scope. * We make sure that if the packet is ill-formed (i.e. the * length of the name (including the length bytes) is > 255, we raise * an exception. Since *pNameLen is counting the number of bytes * in the name that we are forming, we need to compare it with * (255 - 16) = 239 since the first 32 bytes of the netbios name * map to 16 bytes of our internal name. */ if (*pNmInPkt != 0) { if (*pNameLen > MAX_SIZE_INTERNAL_NAME) { goto BadFormat; } if ( --inLen <= 0) { goto BadFormat; } *pName++ = '.'; (*pNameLen)++; Length = LENGTH_MASK & *pNmInPkt; // check that the we have enough space remaining in the input buffer. // if ( (inLen -= Length) <= 0 ) { goto BadFormat; } ++pNmInPkt; //increment past length byte while(Length-- != 0) { *pName++ = *pNmInPkt++; (*pNameLen)++; } } else { ++pNmInPkt; //increment past end byte (00) break; } } if (--inLen >= 0) { *pName++ = 0; /* EOS */ } else { goto BadFormat; } (*pNameLen)++; //include 0 in the name's length so that it is stored //in the db. Check out FormatName too since it expects //the length to include this 0 *ppName = pNmInPkt; //init the ppName ptr to point just past the name return; BadFormat: // log error and raise an exception WINSEVT_LOG_M(WINS_FAILURE, WINS_EVT_PKT_FORMAT_ERR); WINS_RAISE_EXC_M(WINS_EXC_PKT_FORMAT_ERR); return; } STATUS GetOtherInfo( NMSMSGF_NAM_REQ_TYP_E Opcode_e, IN LPBYTE pRR, /*point to the RR_NAME section in the *name registration packet */ IN INT QuesNamSecLen, /*size of Ques name section*/ OUT LPBOOL pfGrp, /*flag -- unique/group entry */ OUT PNMSMSGF_CNT_ADD_T pCntAdd, /*Counted address array*/ OUT PNMSMSGF_NODE_TYP_E pNodeTyp_e ) /*++ Routine Description: The function is called to retrieve information other than the the name from the pkt Arguments: pRR - address of RR_NAME section in the request packet QuesNamSecLen - length of the question names section in the request pkt pfGrp - TRUE if it is a group registration request pAddress - Address contained in the request NodeTyp_e - Type of node doing the registeration (P, B, M) Externals Used: None Called by: NmsMsgfProcNbtReq Comments: None Return Value: Success status codes -- WINS_SUCCESS Error status codes -- WINS_FAILURE --*/ { INT HighTwoBits; BYTE *pTmp = pRR; LONG UNALIGNED *pTmpL; /* * RR_NAME section should contain a pointer to the Question Section. So * we could skip it. We are not, however, just in case another * implementation of NBT does not follow the recommendations of the * RFC and passes us the full name in RR_NAME section */ if ((HighTwoBits = NAME_FORMAT_MASK & *pTmp) == 0) { /* * skip the name (same size as in question_name section) and the * RR_TYPE, RR_CLASS, TTL and RDLENGTH fields */ pTmp += QuesNamSecLen + RFC_LEN_RRTYP_N_RRCLS + RFC_LEN_TTL + RFC_LEN_RDLEN; } else { /* * skip the pointer bytes (2), RR_TYPE, RR_CLASS, TTL, and * RDLENGTH flds */ pTmp += RFC_LEN_RRPTR + RFC_LEN_RRTYP_N_RRCLS + RFC_LEN_TTL + RFC_LEN_RDLEN; } /* * RFC 1002 - page 12 and 14. * * First 16 buts of the RData section (right after the RDLEN section * has its top most bit set to 0 if the registration is for a group */ *pfGrp = GROUP_BIT_MASK & *pTmp; // get the group bit /* *Next two MS bits indicate the node type */ *pNodeTyp_e = (NODE_TYPE_MASK & *pTmp) >> SHIFT_NODE_BITS; /* * Get the IP address. IP address is 2 bytes away, */ pTmp += 2; NONPORT("Port when porting to NON TCP/IP protocols") pCntAdd->NoOfAdds = 1; /* * Use ntohl to get the address which is a long in the correct * byte order */ pTmpL = (LPLONG)pTmp; pCntAdd->Add[0].Add.IPAdd = ntohl(*pTmpL); pCntAdd->Add[0].AddTyp_e = COMM_ADD_E_TCPUDPIP; pCntAdd->Add[0].AddLen = sizeof(COMM_IP_ADD_T); if (Opcode_e == NMSMSGF_E_MULTIH_REG) { USHORT RdLen; USHORT NoOfAddsLeft; // // We are going to register a group of addresses // // // Extract the RDLEN (decrement the pointer) // RdLen = (USHORT)((*(pTmp - RFC_LEN_RDLEN_N_NBF) << 8) + *(pTmp - RFC_LEN_RDLEN_N_NBF + 1)); NoOfAddsLeft = ((RdLen - RFC_LEN_NBFLAGS)/COMM_IP_ADD_SIZE) - 1; if (NoOfAddsLeft >= NMSMSGF_MAX_NO_MULTIH_ADDS) { DBGPRINT0(FLOW, "The packet for multi-homed registration has more than the max. number of ip addresses supported for a multi-homed client. \n"); WINSEVT_LOG_M( NoOfAddsLeft, WINS_EVT_LIMIT_MULTIH_ADD_REACHED ); NoOfAddsLeft = NMSMSGF_MAX_NO_MULTIH_ADDS - 1; } // // Get the remaining addresses // pTmp += RFC_LEN_NBADD; for( ; //null first expr pCntAdd->NoOfAdds < (DWORD)(NoOfAddsLeft + 1); pTmp += RFC_LEN_NBADD, pCntAdd->NoOfAdds++ ) { pCntAdd->Add[pCntAdd->NoOfAdds].Add.IPAdd = ntohl(*((LPLONG)pTmp)); pCntAdd->Add[pCntAdd->NoOfAdds].AddTyp_e = COMM_ADD_E_TCPUDPIP; pCntAdd->Add[pCntAdd->NoOfAdds].AddLen = sizeof(COMM_IP_ADD_T); } } return(WINS_SUCCESS); } STATUS NmsMsgfFrmNamRspMsg( PCOMM_HDL_T pDlgHdl, NMSMSGF_NAM_REQ_TYP_E NamRspTyp_e, PNMSMSGF_RSP_INFO_T pRspInfo ) /*++ Routine Description: This function is called to format a response message for sending to an nbt node. Arguments: pDlgHdl -- Dlg Handle NameRspTye_e -- Type of response message (registration, query, release) that needs to be formatted. pRspInfo -- Response Info. Externals Used: None Called by: NmsNmhNamRegInd, NmsNmhNamRegGrp, NmsNmhNamRel, NmsNmhNamQuery Comments: None Return Value: Success status codes -- WINS_SUCCESS Error status codes -- WINS_FAILURE --*/ { STATUS RetStat = WINS_SUCCESS; LPBYTE pReqBuff = pRspInfo->pMsg; LPBYTE pNewBuff = pReqBuff; // // Switch on type of response // switch(NamRspTyp_e) { case(NMSMSGF_E_NAM_REG): /* fall through */ case(NMSMSGF_E_NAM_REF): case(NMSMSGF_E_NAM_REF_UB): (VOID)FrmNamRegRsp( pDlgHdl, pRspInfo ); break; case(NMSMSGF_E_NAM_QUERY): #if 0 FrmNamQueryRsp( pDlgHdl, pRspInfo ); #endif (VOID)FormatQueryRspBuff( pNewBuff, //ptr to buffer to fill pReqBuff, // ptr to req buffer pRspInfo, FALSE //no danger of truncation since //we never send more than 25 ip add //in the response ); break; case(NMSMSGF_E_NAM_REL): (VOID)FrmNamRelRsp( pDlgHdl, pRspInfo ); break; default: // error RetStat = WINS_FAILURE; break; } return(RetStat); } STATUS FrmNamRegRsp( PCOMM_HDL_T pDlgHdl, PNMSMSGF_RSP_INFO_T pRspInfo ) /*++ Routine Description: This function formats a positive or a negative name registration response. Arguments: pDlgHdl -- Dialogue Handle pRspInfo -- Information used to format the response pkt Externals Used: None Called by: NmsMsgfFrmNamRspMsg Comments: None Return Value: Success status codes -- Error status codes -- --*/ { LPBYTE pTmpB = pRspInfo->pMsg + 2; BYTE SavedByte; /* We will use the same buffer that carried the request. Simple moves will be done. These should be faster than doing all the construction from scratch */ /* Set the the Transaction Id, Opcode, NMFlags and Rcode field */ *pTmpB++ = RFC_NAM_REG_RSP_OPC; *pTmpB++ = RFC_NAM_REG_RSP_4THB + pRspInfo->Rcode_e; /* Set the QD count and the AN count fields */ *pTmpB++ = RFC_NAM_REG_RSP_QDCNT_1STB; *pTmpB++ = RFC_NAM_REG_RSP_QDCNT_2NDB; *pTmpB++ = RFC_NAM_REG_RSP_ANCNT_1STB; *pTmpB++ = RFC_NAM_REG_RSP_ANCNT_2NDB; /* Set the NSCOUNT and ARCOUNT fields */ *pTmpB++ = RFC_NAM_REG_RSP_NSCNT_1STB; *pTmpB++ = RFC_NAM_REG_RSP_NSCNT_2NDB; *pTmpB++ = RFC_NAM_REG_RSP_ARCNT_1STB; *pTmpB++ = RFC_NAM_REG_RSP_ARCNT_2NDB; /* Increment the pointer past the Question_Class Section RR_NAME, RR_TYPE, and RR_CLASS of response are same as Question_Name, Question_Type, and Question_Class of nbt request. */ pTmpB += pRspInfo->QuesNamSecLen + RFC_LEN_QTYP_N_QCLS; SavedByte = *pTmpB & NAME_FORMAT_MASK; //save the format bits of RR section CHECK("In case of a negative response, does it matter what I put in the TTL") CHECK("field. It shouldn't matter -- RFC is silent about this") // // put the TTL in the response // *pTmpB++ = (BYTE)(pRspInfo->RefreshInterval >> 24); *pTmpB++ = (BYTE)((pRspInfo->RefreshInterval >> 16) & 0xFF); *pTmpB++ = (BYTE)((pRspInfo->RefreshInterval >> 8) & 0xFF); *pTmpB++ = (BYTE)(pRspInfo->RefreshInterval & 0xFF); /* Move memory that is after RR_NAME into appropriate place First we check what form the name in the RR_NAME section is. It should be in pointer form (pointer to the QuesNamSec) but could be in the regular form. */ if (SavedByte == 0) { DWORD RRSecLen = pRspInfo->QuesNamSecLen + RFC_LEN_QTYP_N_QCLS; // RR_NAME is as big as the Question_name section. WINSMSC_MOVE_MEMORY_M( pTmpB, pTmpB + RRSecLen, RFC_LEN_RDLEN_N_NBF_N_NBA ); } else { // RR_NAME is a ptr so it takes up 2 bytes. WINSMSC_MOVE_MEMORY_M( pTmpB, pTmpB + RFC_LEN_RRPTR + RFC_LEN_RRTYP_N_RRCLS, RFC_LEN_RDLEN_N_NBF_N_NBA ); } pTmpB += RFC_LEN_RDLEN_N_NBF_N_NBA; pRspInfo->MsgLen = (ULONG) (pTmpB - (LPBYTE)pRspInfo->pMsg); return(WINS_SUCCESS); } STATUS FrmNamRelRsp( PCOMM_HDL_T pDlgHdl, PNMSMSGF_RSP_INFO_T pRspInfo ) /*++ Routine Description: This function formats a positive or negative name query response. The request buffer is made use of for the response. Arguments: pDlgHdl -- Dialogue Handle pRspInfo -- Response Info Externals Used: None Called by: NmsMsgfFrmRspMsg() Comments: None Return Value: Success status codes -- Error status codes -- --*/ { LPBYTE pTmpB = pRspInfo->pMsg + 2; //LPBYTE pTmpB2; /* We will use the same buffer that carried the request. Simple moves will be done. These should be faster than doing all the construction from scratch */ /* Set the the Transaction Id, Opcode, NMFlags and Rcode field */ *pTmpB++ = RFC_NAM_REL_RSP_OPC; *pTmpB++ = RFC_NAM_REL_RSP_4THB + pRspInfo->Rcode_e; /* Set the QD count and the AN count fields */ *pTmpB++ = RFC_NAM_REL_RSP_QDCNT_1STB; *pTmpB++ = RFC_NAM_REL_RSP_QDCNT_2NDB; *pTmpB++ = RFC_NAM_REL_RSP_ANCNT_1STB; *pTmpB++ = RFC_NAM_REL_RSP_ANCNT_2NDB; /* Set the NSCOUNT and ARCOUNT fields */ *pTmpB++ = RFC_NAM_REL_RSP_NSCNT_1STB; *pTmpB++ = RFC_NAM_REL_RSP_NSCNT_2NDB; *pTmpB++ = RFC_NAM_REL_RSP_ARCNT_1STB; *pTmpB++ = RFC_NAM_REL_RSP_ARCNT_2NDB; /* Increment the pointer past the Question_Class Section RR_NAME, RR_TYPE, and RR_CLASS of response are same as Question_Name, Question_Type, and Question_Class of nbt request. */ pTmpB += pRspInfo->QuesNamSecLen + RFC_LEN_QTYP_N_QCLS; if ((*pTmpB & NAME_FORMAT_MASK) == 0) { DWORD RRSecLen = pRspInfo->QuesNamSecLen + RFC_LEN_QTYP_N_QCLS; // RR_NAME is as big as the Question_name section. WINSMSC_MOVE_MEMORY_M( pTmpB, pTmpB + RRSecLen, RFC_LEN_TTL_N_RDLEN_N_NBF_N_NBA ); } else { // RR_NAME is a ptr so it takes up 2 bytes. 2 + 4 = 6 WINSMSC_MOVE_MEMORY_M( pTmpB, pTmpB + RFC_LEN_RRPTR + RFC_LEN_RRTYP_N_RRCLS, RFC_LEN_TTL_N_RDLEN_N_NBF_N_NBA ); } pTmpB += RFC_LEN_TTL_N_RDLEN_N_NBF_N_NBA; #if 0 // not needed. We always return the NBFLAGS and Address of the requestor pTmpB2 = pTmpB - RFC_LEN_NBFLAGS - RFC_LEN_NBADD; // // Set the NBFLAGS field // if (pRspInfo->EntTyp == NMSDB_SPEC_GRP_ENTRY) { *pTmpB2++ = 0x80; *pTmpB2++ = 0x00; } else { COMM_IP_ADD_T IPAdd = pRspInfo->pNodeAdds->Mem[0].Add.Add.IPAdd; if (pRspInfo->EntTyp == NMSDB_NORM_GRP_ENTRY) { *pTmpB2++ = 0x80; } else //it is a unique entry { *pTmpB2++ = pRspInfo->NodeTyp_e << NMSDB_SHIFT_NODE_TYP; } *pTmpB2++ = 0x00; *pTmpB2++ = (BYTE)(IPAdd >> 24); //MSB *pTmpB2++ = (BYTE)((IPAdd >> 16) % 256); *pTmpB2++ = (BYTE)((IPAdd >> 8) % 256); *pTmpB2++ = (BYTE)(IPAdd % 256); //LSB } #endif pRspInfo->MsgLen = (ULONG) (pTmpB - (LPBYTE)pRspInfo->pMsg); return(WINS_SUCCESS); } #if 0 STATUS FrmNamQueryRsp( IN PCOMM_HDL_T pDlgHdl, IN PNMSMSGF_RSP_INFO_T pRspInfo ) /*++ Routine Description: This function formats a name query response Arguments: pDlgHdl -- Dialogue Handle pRspInfo -- Response Info Externals Used: None Called by: NmsNmhFrmRspMsg() Comments: None Return Value: Success status codes -- WINS_SUCCESS Error status codes -- WINS_FAILURE Comments: Not used currently. Will make use of it when we have the potential to send more data than can fit in a query response datagram --*/ { BOOL fTrunc = FALSE; LPBYTE pReqBuff = pRspInfo->pMsg; LPBYTE pNewBuff = pReqBuff; STATUS RetStat = WINS_SUCCESS; FUTURES("Currently, since we never send more than 25 addresses, there is no") FUTURES(" danger of overflowing the buffer. In the future, if we ever change") FUTURES("that, we should unconditinalize the code below, compile it and check") FUTURES("it out. It needs to be modified. The computation of the size") FUTURES("is faulty") DWORD RspLen = 0; BYTE *pTmpB = NULL; /* If this is to be sent as a datagram we will use the same buffer that carries the request. If it is to be sent on a TCP connection we will still use the same buffer if it is a negative name query response. If, however, a positive name query response has to be sent, we will allocate a buffer storing the response */ if ((!COMM_IS_TCP_MSG_M(pDlgHdl)) { /* In the following there is no need to check fGrp flag but let us do it for insurance */ if ((Rcode_e == NMSMSGF_E_SUCCESS) && (NodeAdds.fGrp)) { /* Check if we need to set the truncation bit in the datagram. To do the above, Compute the size of the buffer required to house all the information and compare with the datagram size */ if ( ( RspLen = pDlgHdl->MsgLen + RFC_LEN_TTL_N_RDLEN + (NodeAdds.NoOfMems * sizeof(COMM_IP_ADD_T)) ) > COMM_DATAGRAM_SIZE ) { fTrunc = TRUE; } } } else // TCP message with Rcode_e of success { if ( ( RspLen = *pMsgLen + RFC_LEN_TTL_N_RDLEN + (NodeAdds.NoOfMems * sizeof(COMM_IP_ADD)) ) > COMM_DATAGRAM_SIZE ) { WinsMscAlloc(RspLen, &pNewBuff); if (pNewBuff == NULL) { return(WINS_FAILURE); } } *ppMsg = pNewBuff; Status = FormatQueryRspBuff( pNewBuff, //ptr to buffer to fill pReqBuff, // ptr to req buffer pRspInfo, ftrunc ); WinsMscHeapFree( CommUdpBuffHeapHdl, pReqBuff ); // get rid of the old buffer return(Status); } RetStat = FormatQueryRspBuff( pNewBuff, //ptr to buffer to fill pReqBuff, // ptr to req buffer pRspInfo, fTrunc ); return(RetStat); } #endif STATUS FormatQueryRspBuff( IN LPBYTE pDest, IN LPBYTE pSrc, IN PNMSMSGF_RSP_INFO_T pRspInfo, IN BOOL fTrunc ) /*++ Routine Description: This function formats the response for a name query request Arguments: pDest - Buffer to contain the formatted response pSrc - Buffer containing the formatted request pRspInfo - Response Information fTrunc - whether the response packet is to have the truncation bit set Externals Used: None Called by: FrmNamQueryRsp() Comments: None Return Value: Success status codes -- WINS_SUCCESS Error status codes -- WINS_FAILURE --*/ { DWORD no; LPBYTE pDestB = pDest; DWORD LenOfAdds; DWORD IPAdd; *pDestB++ = *pSrc; *pDestB++ = *(pSrc + 1); /* The Transaction Id, Opcode, NMFlags and Rcode field */ *pDestB++ = ( *(pSrc + 2) | ((fTrunc == FALSE) ? RFC_NAM_QUERY_RSP_OPC_NO_T : RFC_NAM_QUERY_RSP_OPC_T) ); *pDestB++ = RFC_NAM_QUERY_RSP_4THB + pRspInfo->Rcode_e; /* * Set the QD count and the AN count fields */ *pDestB++ = RFC_NAM_QUERY_RSP_QDCNT_1STB; *pDestB++ = RFC_NAM_QUERY_RSP_QDCNT_2NDB; *pDestB++ = RFC_NAM_QUERY_RSP_ANCNT_1STB; *pDestB++ = (pRspInfo->Rcode_e == NMSMSGF_E_SUCCESS) ? RFC_NAM_QUERY_POS_RSP_ANCNT_2NDB : RFC_NAM_QUERY_NEG_RSP_ANCNT_2NDB; /* Set the NSCOUNT and ARCOUNT fields */ *pDestB++ = RFC_NAM_QUERY_RSP_NSCNT_1STB; *pDestB++ = RFC_NAM_QUERY_RSP_NSCNT_2NDB; *pDestB++ = RFC_NAM_QUERY_RSP_ARCNT_1STB; *pDestB++ = RFC_NAM_QUERY_RSP_ARCNT_2NDB; pSrc += pDestB - pDest; /* Increment the counter past the Question_Name Section (which is known as the RR_NAME section here). Use MoveMemory here instead of Copy Memory. Move Memory handles overlapped copies which will happen if pDest and pSrc are pointing to the same buffer */ WINSMSC_MOVE_MEMORY_M( pDestB, pSrc, pRspInfo->QuesNamSecLen ); pDestB += pRspInfo->QuesNamSecLen; if (pRspInfo->Rcode_e == NMSMSGF_E_SUCCESS) { *pDestB++ = RFC_NAM_QUERY_POS_RSP_NB_1STB; //RFC 1002 -- page 22 *pDestB++ = RFC_NAM_QUERY_POS_RSP_NB_2NDB; //RFC 1002 -- page 22 *pDestB++ = RFC_NAM_QUERY_POS_RSP_IN_1STB; //RFC 1002 -- page 22 *pDestB++ = RFC_NAM_QUERY_POS_RSP_IN_2NDB; //RFC 1002 -- page 22 } else { *pDestB++ = RFC_NAM_QUERY_NEG_RSP_NB_1STB; //RFC 1002 -- page 22 *pDestB++ = RFC_NAM_QUERY_NEG_RSP_NB_2NDB; //RFC 1002 -- page 22 *pDestB++ = RFC_NAM_QUERY_NEG_RSP_IN_1STB; //RFC 1002 -- page 22 *pDestB++ = RFC_NAM_QUERY_NEG_RSP_IN_2NDB; //RFC 1002 -- page 22 } if (!fTrunc) { if (pRspInfo->Rcode_e == NMSMSGF_E_SUCCESS) { CHECK("In case of a negative response, does it matter what I put in the TTL") CHECK("field. It shouldn't matter -- RFC is silent about this") /* Put 0 in the TTL field. TTL field will not be looked at by the Client. */ *pDestB++ = 0; *pDestB++ = 0; *pDestB++ = 0; *pDestB++ = 0; // // Get the RDLENGTH value // LenOfAdds = pRspInfo->pNodeAdds->NoOfMems * (RFC_LEN_NBFLAGS + sizeof(COMM_IP_ADD_T)); *pDestB++ = (BYTE)(LenOfAdds >> 8); //MSB *pDestB++ = (BYTE)(LenOfAdds % 256); //LSB // // Put the NBFLAGS here // if ( (pRspInfo->EntTyp != NMSDB_UNIQUE_ENTRY) ) { BYTE Nbflags; DWORD StartIndex; if ( pRspInfo->EntTyp == NMSDB_MULTIHOMED_ENTRY) { Nbflags = pRspInfo->NodeTyp_e << NMSDB_SHIFT_NODE_TYP; } else { // // it is a group (normal/special) // Nbflags = 0x80; } // // It is a group (normal or special) or a multihomed // entry // if (pRspInfo->pNodeAdds->NoOfMems && WinsCnf.fRandomize1CList && NMSDB_SPEC_GRP_ENTRY == pRspInfo->EntTyp ) { StartIndex = rand() % pRspInfo->pNodeAdds->NoOfMems;; } else { StartIndex = 0; } for (no = StartIndex; no < pRspInfo->pNodeAdds->NoOfMems; no++) { *pDestB++ = Nbflags; *pDestB++ = 0x0; IPAdd = pRspInfo->pNodeAdds->Mem[no].Add.Add.IPAdd; NMSMSGF_INSERT_IPADD_M(pDestB, IPAdd); } for (no = 0; no < StartIndex; no++) { *pDestB++ = Nbflags; *pDestB++ = 0x0; IPAdd = pRspInfo->pNodeAdds->Mem[no].Add.Add.IPAdd; NMSMSGF_INSERT_IPADD_M(pDestB, IPAdd); } } else { // // It is a unique entry // *pDestB++ = pRspInfo->NodeTyp_e << NMSDB_SHIFT_NODE_TYP; *pDestB++ = 0x0; IPAdd = pRspInfo->pNodeAdds->Mem[0].Add.Add.IPAdd; NMSMSGF_INSERT_IPADD_M(pDestB, IPAdd); } } else //this is a negative name query response { /* Put 0 in the TTL field. TTL field will not be looked at by the Client. */ *pDestB++ = 0; *pDestB++ = 0; *pDestB++ = 0; *pDestB++ = 0; /* Put 0 in the RDLENGTH field since we are not passing any address(es) */ *pDestB++ = 0; *pDestB++ = 0; } CHECK("When a truncated response is sent to the client, is it ok to not") CHECK("Send any field after the RR_NAME section. RFC is silent about this") CHECK("For now, it is ok, since we will never have a situation where a ") CHECK("truncated response needs to be sent") pRspInfo->MsgLen = (ULONG) (pDestB - pDest); } else { //this is a truncated response (does not have any field after //RR_NAME section pRspInfo->MsgLen = (ULONG) (pDestB - pDest); } return(WINS_SUCCESS); } VOID FormatName( IN LPBYTE pNameToFormat, IN DWORD NamLen, IN OUT LPBYTE *ppFormattedName ) /*++ Routine Description: This function is called to format a name Arguments: pNameToFormat -- Name to format LengthOfName -- Length of Name pFormattedName -- Name after it has been formatted Externals Used: None Return Value: Success status codes -- Error status codes -- Error Handling: Called by: Side Effects: Comments: Note: This function should be called to format only those names whose length as indicated by NameLen includes the ending 0. All names stored in the database are valid. --*/ { LPBYTE pTmpB = *ppFormattedName; DWORD Length; LPBYTE pSaveAdd = pTmpB; //save address of length octet FUTURES("take out the check below to improve performance") // // If NamLen is more then what is prescribed in RFC 1002, // there is something really wrong. This calls for raising // an exception // if (NamLen > RFC_MAX_NAM_LEN) { WINS_RAISE_EXC_M(WINS_FATAL_ERR); } pTmpB++; //skip the length octet. We will write to //it later. We have stored the address in //pSaveAdd NamLen--; //decrement Namelen since we always store //0 at the end of the name. NameLen includes //this extra byte for ( Length = 0; (*pNameToFormat != '.') && (NamLen != 0); Length += 2, NamLen-- ) { *pTmpB++ = 'A' + (*pNameToFormat >> 4); *pTmpB++ = 'A' + (*pNameToFormat++ & 0x0F); } *pSaveAdd = (BYTE)Length; while(NamLen != 0) { pNameToFormat++; //increment past the '.' pSaveAdd = pTmpB++; //save add; skip past length octet NamLen--; //to account for the '.' for ( Length = 0; (*pNameToFormat != '.') && (NamLen != 0); Length++, NamLen-- ) { *pTmpB++ = *pNameToFormat++; } FUTURES("take out the check below to improve performance") // // Make sure there is no weirdness // if (Length > RFC_MAX_LABEL_LEN) { WINS_RAISE_EXC_M(WINS_FATAL_ERR); } *pSaveAdd = (BYTE)Length; if (NamLen == 0) { break; //reached end of name } } *pTmpB++ = EOS; *ppFormattedName = pTmpB; return; } VOID NmsMsgfFrmNamQueryReq( IN DWORD TransId, IN MSG_T pMsg, OUT PMSG_LEN_T pMsgLen, IN LPBYTE pNameToFormat, IN DWORD NameLen ) /*++ Routine Description: This function formats a name query request packet Arguments: TransId - Transaction Id. to use pMsg - Msg Buffer to format pMsgLen - Length of formatted message pNameToFormat - Name to format NameLen - Length of Name Externals Used: None Return Value: None Error Handling: Called by: HandleWrkItm in nmschl.c Side Effects: Comments: None --*/ { LPBYTE pTmpB = pMsg; /* * Put the Transaction Id in */ *pTmpB++ = (BYTE)(TransId >> 8); *pTmpB++ = (BYTE)(TransId & 0xFF); *pTmpB++ = RFC_NAM_QUERY_REQ_OPCB; *pTmpB++ = RFC_NAM_QUERY_REQ_4THB; *pTmpB++ = RFC_NAM_QUERY_REQ_QDCNT_1STB; *pTmpB++ = RFC_NAM_QUERY_REQ_QDCNT_2NDB; *pTmpB++ = RFC_NAM_QUERY_REQ_ANCNT_1STB; *pTmpB++ = RFC_NAM_QUERY_REQ_ANCNT_2NDB; *pTmpB++ = RFC_NAM_QUERY_REQ_NSCNT_1STB; *pTmpB++ = RFC_NAM_QUERY_REQ_NSCNT_2NDB; *pTmpB++ = RFC_NAM_QUERY_REQ_ARCNT_1STB; *pTmpB++ = RFC_NAM_QUERY_REQ_ARCNT_2NDB; FormatName(pNameToFormat, NameLen, &pTmpB); *pTmpB++ = RFC_NAM_QUERY_REQ_QTYP_1STB; *pTmpB++ = RFC_NAM_QUERY_REQ_QTYP_2NDB; *pTmpB++ = RFC_NAM_QUERY_REQ_QCLS_1STB; *pTmpB++ = RFC_NAM_QUERY_REQ_QCLS_2NDB; *pMsgLen = (ULONG) (pTmpB - pMsg); return; } VOID NmsMsgfFrmNamRelReq( IN DWORD TransId, IN MSG_T pMsg, OUT PMSG_LEN_T pMsgLen, IN LPBYTE pNameToFormat, IN DWORD NameLen, IN NMSMSGF_NODE_TYP_E NodeTyp_e, IN PCOMM_ADD_T pNodeAdd ) /*++ Routine Description: This function formats a name release request packet Arguments: TransId - Transaction Id. to use pMsg - Msg Buffer to format pMsgLen - Length of formatted message pNameToFormat - Name to format NameLen - Length of Name NodeTyp_e - Type of Node NodeAdd - IP address of node Externals Used: None Return Value: None Error Handling: Called by: HandleWrkItm() in nmschl.c Side Effects: Comments: None --*/ { LPBYTE pTmpB = pMsg; /* * Put the Transaction Id in */ *pTmpB++ = (BYTE)(TransId >> 8); *pTmpB++ = (BYTE)(TransId & 0xFF); *pTmpB++ = RFC_NAM_REL_REQ_OPCB; *pTmpB++ = RFC_NAM_REL_REQ_4THB; *pTmpB++ = RFC_NAM_REL_REQ_QDCNT_1STB; *pTmpB++ = RFC_NAM_REL_REQ_QDCNT_2NDB; *pTmpB++ = RFC_NAM_REL_REQ_ANCNT_1STB; *pTmpB++ = RFC_NAM_REL_REQ_ANCNT_2NDB; *pTmpB++ = RFC_NAM_REL_REQ_NSCNT_1STB; *pTmpB++ = RFC_NAM_REL_REQ_NSCNT_2NDB; *pTmpB++ = RFC_NAM_REL_REQ_ARCNT_1STB; *pTmpB++ = RFC_NAM_REL_REQ_ARCNT_2NDB; FormatName(pNameToFormat, NameLen, &pTmpB); *pTmpB++ = RFC_NAM_REL_REQ_QTYP_1STB; *pTmpB++ = RFC_NAM_REL_REQ_QTYP_2NDB; *pTmpB++ = RFC_NAM_REL_REQ_QCLS_1STB; *pTmpB++ = RFC_NAM_REL_REQ_QCLS_2NDB; *pTmpB++ = 0xC0; *pTmpB++ = 0x0C; //Name is at offset 12 from start of message *pTmpB++ = RFC_NAM_REL_REQ_RRTYP_1STB; *pTmpB++ = RFC_NAM_REL_REQ_RRTYP_2NDB; *pTmpB++ = RFC_NAM_REL_REQ_RRCLS_1STB; *pTmpB++ = RFC_NAM_REL_REQ_RRCLS_2NDB; // // TTL // *pTmpB++ = 0; *pTmpB++ = 0; *pTmpB++ = 0; *pTmpB++ = 0; // // RDLENGTH field // *pTmpB++ = 0x0; *pTmpB++ = 0x6; //number of bytes to follow // // NBFLAGS word (Bit 15 is Group bit (0); bit 13 and 14 are node // type bits, rest of the bits are reserved // *pTmpB++ = NodeTyp_e << 13; *pTmpB++ = 0; // // Store the IP address. MSB first, LSB last (Network Byte Order) // NMSMSGF_INSERT_IPADD_M(pTmpB, pNodeAdd->Add.IPAdd); *pMsgLen = (ULONG) (pTmpB - pMsg); return; } VOID NmsMsgfFrmWACK( IN LPBYTE pBuff, OUT LPDWORD pBuffLen, IN MSG_T pMsg, IN DWORD QuesNamSecLen, IN DWORD WackTtl ) /*++ Routine Description: This function is called to format a WACK for a name registration request. Arguments: Buff - Buffer to be filled up with WACK msg fields pBuffLen - size of Buffer pMsg - Request Message received QuesNamSecLen - Length of Ques Nam Sec of the request message WackTtl - TTL in msecs Externals Used: None Return Value: None Error Handling: Called by: NmsChlHdlNamReg() Side Effects: Comments: --*/ { LPBYTE pTmpB = pBuff; LPBYTE pName = pMsg + NAME_HEADER_SIZE; DWORD Ttl; // // Compute the TTL in secs (WackTtl is in msecs) // Ttl = WackTtl / 1000; if (WackTtl % 1000 > 0) { Ttl++; } /* * Put the Transaction Id in */ *pTmpB++ = *pMsg; *pTmpB++ = *(pMsg + 1); *pTmpB++ = RFC_WACK_OPCB; *pTmpB++ = RFC_WACK_4THB; *pTmpB++ = RFC_WACK_QDCNT_1STB; *pTmpB++ = RFC_WACK_QDCNT_2NDB; *pTmpB++ = RFC_WACK_ANCNT_1STB; *pTmpB++ = RFC_WACK_ANCNT_2NDB; *pTmpB++ = RFC_WACK_NSCNT_1STB; *pTmpB++ = RFC_WACK_NSCNT_2NDB; *pTmpB++ = RFC_WACK_ARCNT_1STB; *pTmpB++ = RFC_WACK_ARCNT_2NDB; WINSMSC_COPY_MEMORY_M( pTmpB, pName, QuesNamSecLen ); pTmpB += QuesNamSecLen; *pTmpB++ = RFC_WACK_RRTYP_1STB; *pTmpB++ = RFC_WACK_RRTYP_2NDB; *pTmpB++ = RFC_WACK_RRCLS_1STB; *pTmpB++ = RFC_WACK_RRCLS_2NDB; // // TTL // *pTmpB++ = (BYTE)(Ttl >> 24); *pTmpB++ = (BYTE)((Ttl >> 16) % 256); *pTmpB++ = (BYTE)((Ttl >> 8) % 256); *pTmpB++ = (BYTE)(Ttl % 256); *pTmpB++ = RFC_WACK_RDLENGTH_1STB; *pTmpB++ = RFC_WACK_RDLENGTH_2NDB; // // Store the Opcode and NM_FLAGS field. These fields can // be retrieved directly from the 3rd and 4th byte of the message // *pTmpB++ = *(pMsg + 2); *pTmpB++ = *(pMsg + 3); *pBuffLen = (ULONG) (pTmpB - pBuff); return; } STATUS NmsMsgfUfmNamRsp( IN LPBYTE pMsg, OUT PNMSMSGF_NAM_REQ_TYP_E pOpcode_e, OUT LPDWORD pTransId, OUT LPBYTE pName, OUT LPDWORD pNameLen, OUT PNMSMSGF_CNT_ADD_T pCntAdd, //OUT PCOMM_IP_ADD_T pIpAdd, OUT PNMSMSGF_ERR_CODE_E pRcode_e, OUT BOOL *fGroup ) /*++ Routine Description: The function unformats the response message Arguments: pMsg - Msg received (to unformat) pOpcde_e - Opcode pTransId - Transaction Id. pName - Name pNameLen - Name length returned. pIpAdd - IP address pRcode_e - error type (or success) Externals Used: None Called by: ProcRsp in NmsChl.c Comments: None Return Value: Success status codes -- WINS_SUCCESS Error status codes -- WINS_FAILURE --*/ { LPBYTE pTmpB = pMsg; // // get the opcode. Extracts the 4 bits in the 3rd byte (bit 11-bit 14) // *pOpcode_e = (NMS_OPCODE_MASK & *(pTmpB + 2)) >> 3; if ( (*pOpcode_e != NMSMSGF_E_NAM_QUERY) && (*pOpcode_e != NMSMSGF_E_NAM_REL) ) { *pOpcode_e = NMSMSGF_E_INV_REQ; return(WINS_FAILURE); } // // Get the transaction id // *pTransId = (DWORD)((*pTmpB << 8) + *(pTmpB + 1)); // *pTransId |= (DWORD)(*(pTmpB + 1)); // // get the Rcode_e // *pRcode_e = *(pTmpB + 3) % 16; /* * make pTmpB point to the RR Section. All name request/response * packets have a name header of standard size (RFC 1002) at the top */ pTmpB += NAME_HEADER_SIZE; /* * Extract the name ind store in Name. GetName will update pTmp to * point just beyond the name in the RR section */ GetName( &pTmpB, pName, pNameLen ); // // If it is a negative name query response we are done // if ( (*pOpcode_e == NMSMSGF_E_NAM_QUERY) && (*pRcode_e != NMSMSGF_E_SUCCESS) ) { return(WINS_SUCCESS); } else { DWORD i; pTmpB += RFC_LEN_RR_N_TTL; pCntAdd->NoOfAdds = ((*pTmpB << 8) + *(pTmpB + 1))/RFC_LEN_NBF_N_NBA; pTmpB += RFC_LEN_RDLEN; // 15th bit in NBFLAGS indicates if this is a group name *fGroup = (*pTmpB & 0x80 ? TRUE:FALSE); pTmpB += RFC_LEN_NBFLAGS; // // we have either positive query response or a response to a // release // for ( i = 0; #if 0 i < min(pCntAdd->NoOfAdds, NMSMSGF_MAX_NO_MULTIH_ADDS); #endif i < min(pCntAdd->NoOfAdds, NMSMSGF_MAX_ADDRESSES_IN_UDP_PKT); i++ ) { // // Get the IP address. This macro will increment pTmpB by // 4 // NMSMSGF_RETRIEVE_IPADD_M(pTmpB, pCntAdd->Add[i].Add.IPAdd); pCntAdd->Add[i].AddTyp_e = COMM_ADD_E_TCPUDPIP; pCntAdd->Add[i].AddLen = sizeof(PCOMM_IP_ADD_T); pTmpB += RFC_LEN_NBFLAGS; } } return(WINS_SUCCESS); } VOID NmsMsgfSndNamRsp( PCOMM_HDL_T pDlgHdl, LPBYTE pMsg, DWORD MsgLen, DWORD BlockOfReq ) { NMSMSGF_NAM_REQ_TYP_E Opcode; DWORD NameLen; //length of name DWORD QuesNamSecLen; //length of question name section in //packet DWORD Length; LPBYTE pTmp = (LPBYTE)pMsg; LPBYTE pTmp2; NMSMSGF_RSP_INFO_T RspInfo; static DWORD sNoOfTimes = 0; DBGPRINT1(DET, "NmsMsgfSndNamRsp: BlockOfReq is (%d)\n", BlockOfReq); // get the opcode Opcode = (NMS_OPCODE_MASK & *(pTmp + 2)) >> 3; // // if it is a release request, we drop the datagram // if (Opcode == NMSMSGF_E_NAM_REL) { ECommFreeBuff(pMsg); ECommEndDlg(pDlgHdl); return; } /* * make pTmp point to the Question Section. All name request * packets have a name header of standard size (RFC 1002) at the top */ pTmp += NAME_HEADER_SIZE; pTmp2 = pTmp; NameLen = LENGTH_MASK & *pTmp; pTmp += NameLen + 1; //pt pTmp to past the first label NameLen /= 2; while (TRUE) { if (*pTmp != 0) { if (NameLen > MAX_SIZE_INTERNAL_NAME) { ECommFreeBuff(pMsg); ECommEndDlg(pDlgHdl); return; } Length = LENGTH_MASK & *pTmp; NameLen += Length + 1; pTmp += Length + 1; //increment past length and label } else { pTmp++; break; } } QuesNamSecLen = (ULONG) (pTmp - pTmp2); RspInfo.RefreshInterval = 300 * BlockOfReq; // 5 mts RspInfo.Rcode_e = NMSMSGF_E_SUCCESS; RspInfo.pMsg = pMsg; RspInfo.MsgLen = MsgLen; RspInfo.QuesNamSecLen = QuesNamSecLen; NmsNmhSndNamRegRsp( pDlgHdl, &RspInfo ); return; } #if 0 STATUS NmsMsgfFrmNamRegReq( IN DWORD TransId, IN MSG_T pMsg, OUT PMSG_LEN_T pMsgLen, IN LPBYTE pNameToFormat, IN DWORD NameLen, IN NMSMSGF_NODE_TYP_E NodeTyp_e, IN PCOMM_ADD_T pNodeAdd ) /*++ Routine Description: This function is called to format a name registration request Arguments: Externals Used: None Return Value: Success status codes -- Error status codes -- Error Handling: Called by: Side Effects: Comments: This fn gets called when a remote WINS has to be told to increment the version number of --*/ { // // Lets format a name release request since this is exactly the // same as a name registration request except for the 2nd and // 3rd bytes (counting from 0) which house the opcode and // nmflags. We will set these bytes apprropriately after // the following call // NmsMsgfNamRelReq( TransId, pMsg, pMsgLen, pNameToFormat, NameLen, NodeTyp_e, pNodeAdd ); *(pMsg + 2) = 0x29; *(pMsg + 3) = 0x00; return; } #endif