slp-common.h

the User Agent and Service Agent functionality of the Service Location Protocol, based on RFC 2608:

//#define DEBUG
//#define DEBUGSA
//#define DEBUGUA
//#define DEBUGUDP

#define BCAST
#define MULTICAST_ADDR		0xE000000

#ifndef ns_udp_slp_h
#define ns_udp_slp_h

#include "udp.h"
#include "ip.h"
#include "random.h"
#include "packet.h"
#include "app.h"
#include "timer-handler.h"
#include "rtp.h"
#include <string.h>
#include <ctype.h>


#define HDR_SLP(p)		((struct hdr_slp*)hdr_slp::access(p))
#define HDR_SLP_SRVRQST(p)	((struct hdr_slp_srvrqst*)hdr_slp::access(p))
#define HDR_SLP_SRVRPLY(p)	((struct hdr_slp_srvrply*)hdr_slp::access(p))
#define HDR_SLP_SAADVERT(p)	((struct hdr_slp_saadvert*)hdr_slp::access(p))

#define CURRENT_TIME    	Scheduler::instance().clock

#define SLP_MAX_LANGUAGE	1
#define SLP_MAX_PRLIST 		10000
#define SLP_MAX_OUTSTANDING 	1000  // number of outstanding requests
#define SLP_MAX_TYPE 		1
#define SLP_MAX_SCOPE		10
#define SLP_MAX_SERVICE		10
#define SLP_MAX_PREDICATE	1
#define SLP_MAX_SPI		1
#define SLP_MAX_URL		1

#define SLP_INITIAL_TIMEOUT	(double)2.0
#define SLP_CONFIG_MC_MAX	(double)15.0

#define SLP_VERSION		2
#define SLP_LANGUAGE		"en"
#define	SLP_REQUEST_MCAST	0x2000 //bit mask of 00100000 00000000
#define SLP_OVERFLOW		0x8000 //bit mask of 10000000 00000000

#define	REG			1
#define	EXP			2

//packet formats
#define SLPTYPE_SRVRQST		1
#define SLPTYPE_SRVRPLY		2
#define SLPTYPE_SAADVERT	11

static char *small_string(const char *string)
{
  char *newstring = (char *)malloc(sizeof(char)*strlen(string));
  for (int i=0; i<strlen(string); i++)
    newstring[i]=(char)tolower((int)string[i]);
  newstring[strlen(string)]='\0';
  return newstring;
}

//SLP common Header
struct hdr_slp {
        u_int8_t        version;
        u_int8_t        function_id;
	u_int32_t	length : 24;
	u_int16_t	flags;
	u_int32_t	next_ext_offset : 24; //24 bits = 3 byte field
	u_int16_t	xid;
	u_int16_t	language_tag_length;
	const char*     language_tag;	

	// Header access methods
	static int offset_; // required by PacketHeaderManager
	inline static int& offset() { return offset_; }
	inline static hdr_slp* access(const Packet* p) {
	        return (hdr_slp*) p->access(offset_);
	}
};

// srvRqst header
struct hdr_slp_srvrqst {
	/*common slp header*******************************/
        u_int8_t        version;
        u_int8_t        function_id;
	u_int32_t	length : 24;
	u_int16_t	flags;
	u_int32_t	next_ext_offset : 24;
	u_int16_t	xid;
	u_int16_t	language_tag_length;
	const char*     language_tag;
	/*common slp header*******************************/
	u_int16_t	length_prlist;
	const char*	string_prlist;
	u_int16_t	length_service_type;
	const char*	string_service_type;
	u_int16_t	length_scope_list;
	const char*	string_scope_list;
	u_int16_t	length_predicate;
	const char*	string_predicate;
	u_int16_t	length_spi;
	const char*	string_slp;
	
	inline int size() {
                int sz = (2*sizeof(u_int8_t) + 8*sizeof(u_int16_t) + 2*3 
			+((language_tag_length+length_prlist+length_service_type
                           +length_scope_list+length_predicate+length_spi)*sizeof(char)));
                return sz;
        }
};

//url entries
struct hdr_slp_url {
	u_int8_t        reserved;
	u_int16_t       lifetime;
	u_int16_t       url_length;
	const char*     url;
	u_int8_t        auth_no;
	const char*     auth;
	
	inline int size() {
                int sz =  (2*sizeof(u_int8_t) + 2*sizeof(u_int16_t) + ((url_length+auth_no)*sizeof(char)));
                return sz;	
	}
};	

// srvRply header
struct hdr_slp_srvrply {
	/*common slp header*******************************/
        u_int8_t        version;
        u_int8_t        function_id;
	u_int32_t	length : 24;
	u_int16_t	flags;
	u_int32_t	next_ext_offset : 24;
	u_int16_t	xid;
	u_int16_t	language_tag_length;
	const char*     language_tag;
	/*common slp header*******************************/
	u_int16_t	error_code;
	u_int16_t	url_entry_count;
	const char*	url;
	
	inline int url_size()
	{
		int sz=0;
		char *ptr = (char *)url;
		int index=0;	  
	  	for (int i=0; i<url_entry_count; i++)
		{
			sz  += (((hdr_slp_url *)(url+index))->size());
			index += sizeof(hdr_slp_url);
	 	}
	  	return sz;
	}
	inline int size() {
		int sz = (2*sizeof(u_int8_t) + 5*sizeof(u_int16_t) + 2*3 
                            +(language_tag_length*sizeof(char)) + url_size());          
  		return sz;
        }
	
};

// SAAdvert header
struct hdr_slp_saadvert {
	/*common slp header*******************************/
        u_int8_t        version;
        u_int8_t        function_id;
	u_int32_t	length : 24;
	u_int16_t	flags;
	u_int32_t	next_ext_offset : 24;
	u_int16_t	xid;
	u_int16_t	language_tag_length;
	const char*     language_tag;
	/*common slp header*******************************/
	u_int16_t	length_url;
	const char*	url;
	u_int16_t	length_scope_list;
	const char*	string_scope_list;
	u_int16_t	length_attr_list;
	const char*	string_attr_list;	
	u_int8_t        auth_no;
	const char*     auth;
	

	inline int size() {
		int sz = 3*sizeof(u_int8_t) + 6*sizeof(u_int16_t) + 2*3 
                            +( (language_tag_length+length_url+length_scope_list
                               +length_attr_list+auth_no)*sizeof(char));          
  		return sz;
        }
	
};
// for size calculation of header-space reservation
union hdr_slp_all {
  hdr_slp	   sh;
  hdr_slp_srvrqst  srvrqst;
  hdr_slp_srvrply  srvrply;
  hdr_slp_saadvert saadvert;
};

	
#endif