smb_hfield_add_netaddr(), and by extension, the smb_hfield_netaddr() macro,

If the specified or detected net_type is not Internet, only store the address
portion of the email address in the *NETADDR hfield.
If the net_type argument is a NULL pointer, automatically add the *NETTYPE
hfield too.
New functions:
- smb_netaddr_type() - returns the string/name of a specified net_type.
- smb_get_net_type_by_addr() - parses just the network address field.
Change short/ushort's to int16_t/uint16_t's.
Remove date from copyright.

src/smblib/smbadd.c

@@ -8,7 +8,7 @@
  * @format.tab-size 4		(Plain Text/Source Code File Header)			*
  * @format.use-tabs true	(see http://www.synchro.net/ptsc_hdr.html)		*
  *																			*
- * Copyright 2012 Rob Swindell - http://www.synchro.net/copyright.html		*
+ * Copyright Rob Swindell - http://www.synchro.net/copyright.html			*
  *																			*
  * This library is free software; you can redistribute it and/or			*
  * modify it under the terms of the GNU Lesser General Public License		*

src/smblib/smballoc.c

@@ -8,7 +8,7 @@
  * @format.tab-size 4		(Plain Text/Source Code File Header)			*
  * @format.use-tabs true	(see http://www.synchro.net/ptsc_hdr.html)		*
  *																			*
- * Copyright 2005 Rob Swindell - http://www.synchro.net/copyright.html		*
+ * Copyright Rob Swindell - http://www.synchro.net/copyright.html			*
  *																			*
  * This library is free software; you can redistribute it and/or			*
  * modify it under the terms of the GNU Lesser General Public License		*
@@ -246,7 +246,7 @@ int SMBCALL smb_incmsg_dfields(smb_t* smb, smbmsg_t* msg, uint16_t refs)
 {
 	int		i=SMB_SUCCESS;
 	BOOL	da_opened=FALSE;
-	ushort	x;
+	uint16_t	x;
 
 	if(smb->status.attr&SMB_HYPERALLOC)  /* Nothing to do */
 		return(SMB_SUCCESS);
@@ -300,7 +300,7 @@ int SMBCALL smb_freemsghdr(smb_t* smb, ulong offset, ulong length)
 int SMBCALL smb_freemsg_dfields(smb_t* smb, smbmsg_t* msg, uint16_t refs)
 {
 	int		i;
-	ushort	x;
+	uint16_t	x;
 
 	for(x=0;x<msg->hdr.total_dfields;x++) {
 		if((i=smb_freemsgdat(smb,msg->hdr.offset+msg->dfield[x].offset

src/smblib/smbdump.c

@@ -8,7 +8,7 @@
  * @format.tab-size 4		(Plain Text/Source Code File Header)			*
  * @format.use-tabs true	(see http://www.synchro.net/ptsc_hdr.html)		*
  *																			*
- * Copyright 2012 Rob Swindell - http://www.synchro.net/copyright.html		*
+ * Copyright Rob Swindell - http://www.synchro.net/copyright.html			*
  *																			*
  * This program is free software; you can redistribute it and/or			*
  * modify it under the terms of the GNU General Public License				*
@@ -39,7 +39,7 @@
 #include <string.h>		/* strcat */
 #include "smblib.h"
 
-static char *binstr(uchar *buf, ushort length)
+static char *binstr(uchar *buf, uint16_t length)
 {
 	static char str[512];
 	int i;

src/smblib/smbfile.c

@@ -8,7 +8,7 @@
  * @format.tab-size 4		(Plain Text/Source Code File Header)			*
  * @format.use-tabs true	(see http://www.synchro.net/ptsc_hdr.html)		*
  *																			*
- * Copyright 2005 Rob Swindell - http://www.synchro.net/copyright.html		*
+ * Copyright Rob Swindell - http://www.synchro.net/copyright.html			*
  *																			*
  * This library is free software; you can redistribute it and/or			*
  * modify it under the terms of the GNU Lesser General Public License		*

src/smblib/smbhash.c

@@ -8,7 +8,7 @@
  * @format.tab-size 4		(Plain Text/Source Code File Header)			*
  * @format.use-tabs true	(see http://www.synchro.net/ptsc_hdr.html)		*
  *																			*
- * Copyright 2012 Rob Swindell - http://www.synchro.net/copyright.html		*
+ * Copyright Rob Swindell - http://www.synchro.net/copyright.html			*
  *																			*
  * This library is free software; you can redistribute it and/or			*
  * modify it under the terms of the GNU Lesser General Public License		*

src/smblib/smblib.c

@@ -758,7 +758,7 @@ ulong SMBCALL smb_getmsgtxtlen(smbmsg_t* msg)
 	return(length);
 }
 
-static void set_convenience_ptr(smbmsg_t* msg, ushort hfield_type, void* hfield_dat)
+static void set_convenience_ptr(smbmsg_t* msg, uint16_t hfield_type, void* hfield_dat)
 {
 	switch(hfield_type) {	/* convenience variables */
 		case AUTHOR:
@@ -774,7 +774,7 @@ static void set_convenience_ptr(smbmsg_t* msg, ushort hfield_type, void* hfield_
 			break;
 		case SENDERAGENT:
 			if(!msg->forwarded)
-				msg->from_agent=*(ushort *)hfield_dat;
+				msg->from_agent=*(uint16_t *)hfield_dat;
 			break;
 		case SENDEREXT:
 			if(!msg->forwarded)
@@ -786,7 +786,7 @@ static void set_convenience_ptr(smbmsg_t* msg, ushort hfield_type, void* hfield_
 			break;
 		case SENDERNETTYPE:
 			if(!msg->forwarded)
-				msg->from_net.type=*(ushort *)hfield_dat;
+				msg->from_net.type=*(uint16_t *)hfield_dat;
 			break;
 		case SENDERNETADDR:
 			if(!msg->forwarded)
@@ -808,10 +808,10 @@ static void set_convenience_ptr(smbmsg_t* msg, ushort hfield_type, void* hfield_
 			msg->replyto_ext=(char*)hfield_dat;
 			break;
 		case REPLYTOAGENT:
-			msg->replyto_agent=*(ushort *)hfield_dat;
+			msg->replyto_agent=*(uint16_t *)hfield_dat;
 			break;
 		case REPLYTONETTYPE:
-			msg->replyto_net.type=*(ushort *)hfield_dat;
+			msg->replyto_net.type=*(uint16_t *)hfield_dat;
 			break;
 		case REPLYTONETADDR:
 			msg->replyto_net.addr=(char*)hfield_dat;
@@ -823,10 +823,10 @@ static void set_convenience_ptr(smbmsg_t* msg, ushort hfield_type, void* hfield_
 			msg->to_ext=(char*)hfield_dat;
 			break;
 		case RECIPIENTAGENT:
-			msg->to_agent=*(ushort *)hfield_dat;
+			msg->to_agent=*(uint16_t *)hfield_dat;
 			break;
 		case RECIPIENTNETTYPE:
-			msg->to_net.type=*(ushort *)hfield_dat;
+			msg->to_net.type=*(uint16_t *)hfield_dat;
 			break;
 		case RECIPIENTNETADDR:
 			msg->to_net.addr=(char*)hfield_dat;
@@ -925,7 +925,7 @@ static void clear_convenience_ptrs(smbmsg_t* msg)
 int SMBCALL smb_getmsghdr(smb_t* smb, smbmsg_t* msg)
 {
 	void	*vp,**vpp;
-	ushort	i;
+	uint16_t	i;
 	ulong	l,offset;
 	idxrec_t idx;
 
@@ -1064,7 +1064,7 @@ int SMBCALL smb_getmsghdr(smb_t* smb, smbmsg_t* msg)
 /****************************************************************************/
 void SMBCALL smb_freemsghdrmem(smbmsg_t* msg)
 {
-	ushort	i;
+	uint16_t	i;
 
 	for(i=0;i<msg->total_hfields;i++)
 		if(msg->hfield_dat[i]) {
@@ -1171,7 +1171,7 @@ int SMBCALL smb_unlockmsghdr(smb_t* smb, smbmsg_t* msg)
 /****************************************************************************/
 /* Adds a header field to the 'msg' structure (in memory only)              */
 /****************************************************************************/
-int SMBCALL smb_hfield_add(smbmsg_t* msg, ushort type, size_t length, void* data, BOOL insert)
+int SMBCALL smb_hfield_add(smbmsg_t* msg, uint16_t type, size_t length, void* data, BOOL insert)
 {
 	void**		vpp;
 	hfield_t*	hp;
@@ -1232,35 +1232,57 @@ int	SMBCALL smb_hfield_add_list(smbmsg_t* msg, hfield_t** hfield_list, void** hf
 /****************************************************************************/
 /* Convenience function to add an ASCIIZ string header field				*/
 /****************************************************************************/
-int SMBCALL smb_hfield_add_str(smbmsg_t* msg, ushort type, const char* str, BOOL insert)
+int SMBCALL smb_hfield_add_str(smbmsg_t* msg, uint16_t type, const char* str, BOOL insert)
 {
 	return smb_hfield_add(msg, type, str==NULL ? 0:strlen(str), (void*)str, insert);
 }
 
 /****************************************************************************/
-/* Convenience function to add an ASCIIZ string header field				*/
+/* Convenience function to a network address header field to msg			*/
+/* Pass NULL for net_type to have the auto-detected net_type hfield	added	*/
+/* as well.																	*/
 /****************************************************************************/
-int	SMBCALL smb_hfield_add_netaddr(smbmsg_t* msg, ushort type, const char* str, ushort* nettype, BOOL insert)
+int	SMBCALL smb_hfield_add_netaddr(smbmsg_t* msg, uint16_t type, const char* addr, uint16_t* net_type, BOOL insert)
 {
+	int			result;
 	fidoaddr_t	sys_addr = {0,0,0,0};	/* replace unspecified fields with 0 (don't assume 1:1/1) */
 	fidoaddr_t	fidoaddr;
-	ushort		tmp_nettype=NET_UNKNOWN;
-
-	if(nettype==NULL)
-		nettype=&tmp_nettype;
-	if(*nettype==NET_UNKNOWN)
-		*nettype=smb_netaddr_type(str);
-	if(*nettype==NET_FIDO) {
-		fidoaddr=smb_atofaddr(&sys_addr,str);
-		return smb_hfield_add(msg,type,sizeof(fidoaddr),&fidoaddr,insert);
-	} else
-		return smb_hfield_add_str(msg,type,str,insert);
+	uint16_t	tmp_net_type=NET_UNKNOWN;
+	
+	SKIP_WHITESPACE(addr);
+	if(net_type==NULL)
+		net_type=&tmp_net_type;
+	if(*net_type==NET_UNKNOWN)
+		*net_type=smb_netaddr_type(addr);
+	if(*net_type==NET_NONE)
+		return SMB_ERR_NOT_FOUND;
+	if(*net_type!=NET_INTERNET) {	/* Only Internet net-addresses are allowed to have '@' in them */
+		const char* p = strchr(addr, '@');
+		if(p != NULL) {
+			p++;
+			SKIP_WHITESPACE(p);
+			if(*p == 0)
+				return SMB_ERR_NOT_FOUND;;
+			addr = p;
+		}
+	}
+	if(*net_type==NET_FIDO) {
+		fidoaddr=smb_atofaddr(&sys_addr,addr);
+		result = smb_hfield_add(msg,type,sizeof(fidoaddr),&fidoaddr,insert);
+	} else {
+		result = smb_hfield_add_str(msg,type,addr,insert);
+	}
+	if(result==SMB_SUCCESS && net_type == &tmp_net_type) {
+		// *NETTYPE is always *NETADDR-1
+		result = smb_hfield_add(msg,type-1,sizeof(*net_type),net_type,insert);
+	}
+	return result;
 }
 
 /****************************************************************************/
 /* Appends data to an existing header field (in memory only)				*/
 /****************************************************************************/
-int SMBCALL smb_hfield_append(smbmsg_t* msg, ushort type, size_t length, void* data)
+int SMBCALL smb_hfield_append(smbmsg_t* msg, uint16_t type, size_t length, void* data)
 {
 	int		i;
 	BYTE*	p;
@@ -1297,7 +1319,7 @@ int SMBCALL smb_hfield_append(smbmsg_t* msg, ushort type, size_t length, void* d
 /****************************************************************************/
 /* Appends data to an existing ASCIIZ header field (in memory only)			*/
 /****************************************************************************/
-int SMBCALL smb_hfield_append_str(smbmsg_t* msg, ushort type, const char* str)
+int SMBCALL smb_hfield_append_str(smbmsg_t* msg, uint16_t type, const char* str)
 {
 	return smb_hfield_append(msg, type, str==NULL ? 0:strlen(str), (void*)str);
 }
@@ -1305,7 +1327,7 @@ int SMBCALL smb_hfield_append_str(smbmsg_t* msg, ushort type, const char* str)
 /****************************************************************************/
 /* Replaces an header field value (in memory only)							*/
 /****************************************************************************/
-int SMBCALL smb_hfield_replace(smbmsg_t* msg, ushort type, size_t length, void* data)
+int SMBCALL smb_hfield_replace(smbmsg_t* msg, uint16_t type, size_t length, void* data)
 {
 	int		i;
 	void*	p;
@@ -1335,7 +1357,7 @@ int SMBCALL smb_hfield_replace(smbmsg_t* msg, ushort type, size_t length, void*
 /****************************************************************************/
 /* Replace an existing ASCIIZ header field value (in memory only)			*/
 /****************************************************************************/
-int SMBCALL smb_hfield_replace_str(smbmsg_t* msg, ushort type, const char* str)
+int SMBCALL smb_hfield_replace_str(smbmsg_t* msg, uint16_t type, const char* str)
 {
 	return smb_hfield_replace(msg, type, str==NULL ? 0:strlen(str), (void*)str);
 }
@@ -1343,7 +1365,7 @@ int SMBCALL smb_hfield_replace_str(smbmsg_t* msg, ushort type, const char* str)
 /****************************************************************************/
 /* Searches for a specific header field (by type) and returns it			*/
 /****************************************************************************/
-void* SMBCALL smb_get_hfield(smbmsg_t* msg, ushort type, hfield_t* hfield)
+void* SMBCALL smb_get_hfield(smbmsg_t* msg, uint16_t type, hfield_t* hfield)
 {
 	int i;
 
@@ -1362,7 +1384,7 @@ void* SMBCALL smb_get_hfield(smbmsg_t* msg, ushort type, hfield_t* hfield)
 /* Automatically figures out the offset into the data buffer from existing	*/
 /* dfield lengths															*/
 /****************************************************************************/
-int SMBCALL smb_dfield(smbmsg_t* msg, ushort type, ulong length)
+int SMBCALL smb_dfield(smbmsg_t* msg, uint16_t type, ulong length)
 {
 	dfield_t* dp;
 	int i,j;
@@ -1531,7 +1553,7 @@ int SMBCALL smb_addmsghdr(smb_t* smb, smbmsg_t* msg, int storage)
 
 	if(msg->hdr.version==0)
 		msg->hdr.version=SMB_VERSION;
-	msg->hdr.length=(ushort)hdrlen;
+	msg->hdr.length=(uint16_t)hdrlen;
 	if(storage==SMB_HYPERALLOC)
 		l=smb_hallochdr(smb);
 	else if(storage==SMB_FASTALLOC)
@@ -1673,7 +1695,7 @@ int SMBCALL smb_putmsgidx(smb_t* smb, smbmsg_t* msg)
 /****************************************************************************/
 int SMBCALL smb_putmsghdr(smb_t* smb, smbmsg_t* msg)
 {
-	ushort	i;
+	uint16_t	i;
 	ulong	hdrlen;
 
 	if(smb->shd_fp==NULL) {
@@ -1707,7 +1729,7 @@ int SMBCALL smb_putmsghdr(smb_t* smb, smbmsg_t* msg)
 			,msg->hdr.length, smb_hdrblocks(msg->hdr.length));
 		return(SMB_ERR_HDR_LEN);
 	}
-	msg->hdr.length=(ushort)hdrlen; /* store the actual header length */
+	msg->hdr.length=(uint16_t)hdrlen; /* store the actual header length */
 	/**********************************/
 	/* Set the message header ID here */
 	/**********************************/
@@ -1839,7 +1861,7 @@ ulong SMBCALL smb_hdrblocks(ulong length)
 /****************************************************************************/
 /* Returns difference from specified timezone and UTC/GMT (in minutes)		*/
 /****************************************************************************/
-int SMBCALL smb_tzutc(short zone)
+int SMBCALL smb_tzutc(int16_t zone)
 {
 	int tz;
 

src/smblib/smblib.h

@@ -125,14 +125,14 @@ SMBEXPORT int 		SMBCALL smb_getmsghdr(smb_t* smb, smbmsg_t* msg);
 SMBEXPORT int 		SMBCALL smb_unlockmsghdr(smb_t* smb, smbmsg_t* msg);
 SMBEXPORT int 		SMBCALL smb_addcrc(smb_t* smb, uint32_t crc);
 
-SMBEXPORT int 		SMBCALL smb_hfield_add(smbmsg_t* msg, ushort type, size_t length, void* data, BOOL insert);
-SMBEXPORT int		SMBCALL smb_hfield_add_str(smbmsg_t* msg, ushort type, const char* str, BOOL insert);
-SMBEXPORT int		SMBCALL	smb_hfield_replace(smbmsg_t* msg, ushort type, size_t length, void* data);
-SMBEXPORT int		SMBCALL	smb_hfield_replace_str(smbmsg_t* msg, ushort type, const char* str);
-SMBEXPORT int		SMBCALL smb_hfield_append(smbmsg_t* msg, ushort type, size_t length, void* data);
-SMBEXPORT int		SMBCALL smb_hfield_append_str(smbmsg_t* msg, ushort type, const char* data);
+SMBEXPORT int 		SMBCALL smb_hfield_add(smbmsg_t* msg, uint16_t type, size_t length, void* data, BOOL insert);
+SMBEXPORT int		SMBCALL smb_hfield_add_str(smbmsg_t* msg, uint16_t type, const char* str, BOOL insert);
+SMBEXPORT int		SMBCALL	smb_hfield_replace(smbmsg_t* msg, uint16_t type, size_t length, void* data);
+SMBEXPORT int		SMBCALL	smb_hfield_replace_str(smbmsg_t* msg, uint16_t type, const char* str);
+SMBEXPORT int		SMBCALL smb_hfield_append(smbmsg_t* msg, uint16_t type, size_t length, void* data);
+SMBEXPORT int		SMBCALL smb_hfield_append_str(smbmsg_t* msg, uint16_t type, const char* data);
 SMBEXPORT int		SMBCALL smb_hfield_add_list(smbmsg_t* msg, hfield_t** hfield_list, void** hfield_dat, BOOL insert);
-SMBEXPORT int		SMBCALL smb_hfield_add_netaddr(smbmsg_t* msg, ushort type, const char* str, ushort* nettype, BOOL insert);
+SMBEXPORT int		SMBCALL smb_hfield_add_netaddr(smbmsg_t* msg, uint16_t type, const char* str, uint16_t* nettype, BOOL insert);
 /* Convenience macro: */
 #define smb_hfield_bin(msg, type, data) smb_hfield_add(msg, type, sizeof(data), &(data), /* insert: */FALSE)
 /* Backward compatibility macros: */
@@ -140,8 +140,8 @@ SMBEXPORT int		SMBCALL smb_hfield_add_netaddr(smbmsg_t* msg, ushort type, const
 #define smb_hfield_str(msg, type, str)	smb_hfield_add_str(msg, type, str, /* insert: */FALSE)
 #define smb_hfield_netaddr(msg, type, str, nettype) smb_hfield_add_netaddr(msg, type, str, nettype, /* insert: */FALSE)
 
-SMBEXPORT int 		SMBCALL smb_dfield(smbmsg_t* msg, ushort type, ulong length);
-SMBEXPORT void*		SMBCALL smb_get_hfield(smbmsg_t* msg, ushort type, hfield_t* hfield);
+SMBEXPORT int 		SMBCALL smb_dfield(smbmsg_t* msg, uint16_t type, ulong length);
+SMBEXPORT void*		SMBCALL smb_get_hfield(smbmsg_t* msg, uint16_t type, hfield_t* hfield);
 SMBEXPORT int 		SMBCALL smb_addmsghdr(smb_t* smb, smbmsg_t* msg, int storage);
 SMBEXPORT int 		SMBCALL smb_putmsg(smb_t* smb, smbmsg_t* msg);
 SMBEXPORT int 		SMBCALL smb_putmsgidx(smb_t* smb, smbmsg_t* msg);
@@ -151,7 +151,7 @@ SMBEXPORT void		SMBCALL smb_freemsghdrmem(smbmsg_t* msg);
 SMBEXPORT ulong		SMBCALL smb_hdrblocks(ulong length);
 SMBEXPORT ulong		SMBCALL smb_datblocks(ulong length);
 SMBEXPORT int		SMBCALL	smb_copymsgmem(smb_t* smb, smbmsg_t* destmsg, smbmsg_t* srcmsg);
-SMBEXPORT int		SMBCALL smb_tzutc(short timezone);
+SMBEXPORT int		SMBCALL smb_tzutc(int16_t timezone);
 SMBEXPORT int		SMBCALL smb_updatethread(smb_t* smb, smbmsg_t* remsg, ulong newmsgnum);
 SMBEXPORT int		SMBCALL smb_updatemsg(smb_t* smb, smbmsg_t* msg);
 SMBEXPORT BOOL		SMBCALL smb_valid_hdr_offset(smb_t* smb, ulong offset);
@@ -215,18 +215,19 @@ SMBEXPORT int 		SMBCALL smb_getmsghdr_by_hash(smb_t* smb, smbmsg_t* msg, unsigne
 		smb_getmsghdr_by_hashstr(smb, msg, SMB_HASH_SOURCE_FTN_ID, SMB_HASH_MASK, id)
 
 /* smbstr.c */
-SMBEXPORT char*		SMBCALL smb_hfieldtype(ushort type);
-SMBEXPORT ushort	SMBCALL smb_hfieldtypelookup(const char*);
-SMBEXPORT char*		SMBCALL smb_dfieldtype(ushort type);
+SMBEXPORT char*		SMBCALL smb_hfieldtype(uint16_t type);
+SMBEXPORT uint16_t	SMBCALL smb_hfieldtypelookup(const char*);
+SMBEXPORT char*		SMBCALL smb_dfieldtype(uint16_t type);
 SMBEXPORT char*		SMBCALL smb_faddrtoa(fidoaddr_t* addr, char* outstr);
 SMBEXPORT char*		SMBCALL smb_netaddr(net_t* net);
 SMBEXPORT char*		SMBCALL smb_netaddrstr(net_t* net, char* fidoaddr_buf);
-SMBEXPORT ushort	SMBCALL smb_netaddr_type(const char* str);
-SMBEXPORT char*		SMBCALL smb_zonestr(short zone, char* outstr);
+SMBEXPORT char*		SMBCALL	smb_nettype(enum smb_net_type);
+SMBEXPORT char*		SMBCALL smb_zonestr(int16_t zone, char* outstr);
 SMBEXPORT char*		SMBCALL smb_hashsource(smbmsg_t* msg, int source);
 SMBEXPORT char*		SMBCALL smb_hashsourcetype(uchar type);
 SMBEXPORT fidoaddr_t SMBCALL smb_atofaddr(const fidoaddr_t* sys_addr, const char *str);
-
+SMBEXPORT enum smb_net_type SMBCALL smb_netaddr_type(const char* addr);
+SMBEXPORT enum smb_net_type SMBCALL smb_get_net_type_by_addr(const char* addr);
 /* smbdump.c */
 SMBEXPORT void		SMBCALL smb_dump_msghdr(FILE* fp, smbmsg_t* msg);
 

src/smblib/smbstr.c

@@ -8,7 +8,7 @@
  * @format.tab-size 4		(Plain Text/Source Code File Header)			*
  * @format.use-tabs true	(see http://www.synchro.net/ptsc_hdr.html)		*
  *																			*
- * Copyright 2011 Rob Swindell - http://www.synchro.net/copyright.html		*
+ * Copyright Rob Swindell - http://www.synchro.net/copyright.html			*
  *																			*
  * This library is free software; you can redistribute it and/or			*
  * modify it under the terms of the GNU Lesser General Public License		*
@@ -40,7 +40,7 @@
 #include <genwrap.h> 		/* stricmp */
 #include "smblib.h"
 
-char* SMBCALL smb_hfieldtype(ushort type)
+char* SMBCALL smb_hfieldtype(uint16_t type)
 {
 	static char str[8];
 
@@ -119,12 +119,12 @@ char* SMBCALL smb_hfieldtype(ushort type)
 	return(str);
 }
 
-ushort SMBCALL smb_hfieldtypelookup(const char* str)
+uint16_t SMBCALL smb_hfieldtypelookup(const char* str)
 {
-	ushort type;
+	uint16_t type;
 
 	if(isdigit(*str))
-		return((ushort)strtol(str,NULL,0));
+		return((uint16_t)strtol(str,NULL,0));
 
 	for(type=0;type<=UNUSED;type++)
 		if(stricmp(str,smb_hfieldtype(type))==0)
@@ -133,7 +133,7 @@ ushort SMBCALL smb_hfieldtypelookup(const char* str)
 	return(UNKNOWN);
 }
 
-char* SMBCALL smb_dfieldtype(ushort type)
+char* SMBCALL smb_dfieldtype(uint16_t type)
 {
 	static char str[8];
 
@@ -176,14 +176,14 @@ char* SMBCALL smb_hashsource(smbmsg_t* msg, int source)
 /****************************************************************************/
 /* Converts when_t.zone into ASCII format                                   */
 /****************************************************************************/
-char* SMBCALL smb_zonestr(short zone, char* str)
+char* SMBCALL smb_zonestr(int16_t zone, char* str)
 {
 	char*		plus;
     static char buf[32];
 
 	if(str==NULL)
 		str=buf;
-	switch((ushort)zone) {
+	switch((uint16_t)zone) {
 		case 0:     return("UTC");
 		case AST:   return("AST");
 		case EST:   return("EST");
@@ -320,12 +320,9 @@ char* SMBCALL smb_netaddrstr(net_t* net, char* fidoaddr_buf)
 /****************************************************************************/
 /* Returns net_type for passed e-mail address (i.e. "user@addr")			*/
 /****************************************************************************/
-ushort SMBCALL smb_netaddr_type(const char* str)
+enum smb_net_type SMBCALL smb_netaddr_type(const char* str)
 {
 	char*	p;
-	char*	tp;
-	char*	firstdot;
-	char*	lastdot;
 
 	if((p=strchr(str,'@'))==NULL)
 		return(NET_NONE);
@@ -335,6 +332,32 @@ ushort SMBCALL smb_netaddr_type(const char* str)
 	if(*p==0)
 		return(NET_UNKNOWN);
 
+	return smb_get_net_type_by_addr(p);
+}
+
+/****************************************************************************/
+/* Returns net_type for passed network address 								*/
+/* The only addresses expected with an '@' are Internet/SMTP addresses		*/
+/* Examples:																*/
+/*	"VERT"				= NET_QWK											*/
+/*	"1:103/705"			= NET_FIDO											*/
+/*	"705.0"				= NET_FIDO											*/
+/*	"705"				= NET_FIDO											*/
+/*	"192.168.1.0"		= NET_INTERNET										*/
+/*	"some.host"			= NET_INTERNET										*/
+/*	"someone@anywhere"	= NET_INTERNET										*/
+/*	"someone@some.host"	= NET_INTERNET										*/
+/****************************************************************************/
+enum smb_net_type SMBCALL smb_get_net_type_by_addr(const char* addr)
+{
+	const char*	p = addr;
+	const char*	tp;
+	char*	firstdot;
+	char*	lastdot;
+
+	if(strchr(p,'@') != NULL)
+		return(NET_INTERNET);
+
 	firstdot=strchr(p,'.');
 	lastdot=strrchr(p,'.');
 
@@ -352,3 +375,15 @@ ushort SMBCALL smb_netaddr_type(const char* str)
 
 	return(NET_UNKNOWN);
 }
+
+char* SMBCALL smb_nettype(enum smb_net_type type)
+{
+	switch(type) {
+		case NET_NONE:		return "NONE";
+		case NET_UNKNOWN:	return "UNKNOWN";
+		case NET_QWK:		return "QWKnet";
+		case NET_FIDO:		return "Fidonet";
+		case NET_INTERNET:	return "Internet";
+	}
+	return "Unsupported net type";
+}