diff options
| -rw-r--r-- | include/m_netlib.h | 754 | ||||
| -rw-r--r-- | protocols/SkypeWeb/src/http_request.h | 22 | ||||
| -rw-r--r-- | src/modules/netlib/netlibhttp.cpp | 11 |
3 files changed, 426 insertions, 361 deletions
diff --git a/include/m_netlib.h b/include/m_netlib.h index 54898493f3..6248ec1219 100644 --- a/include/m_netlib.h +++ b/include/m_netlib.h @@ -2,7 +2,7 @@ Miranda NG: the free IM client for Microsoft* Windows*
-Copyright (ñ) 2012-15 Miranda NG project (http://miranda-ng.org)
+Copyright (ñ) 2012-15 Miranda NG project (http:// miranda-ng.org)
Copyright (c) 2000-12 Miranda ICQ/IM project,
all portions of this codebase are copyrighted to the people
listed in contributors.txt.
@@ -27,16 +27,17 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #include "m_utils.h"
-//this module was created in 0.1.2.2
-//All error codes are returned via GetLastError() (or WSAGetLastError():
-//they're the same).
-//This module is thread-safe where it is sensible for it to be so. This
-//basically means that you can call anything from any thread, but don't try
-//to predict what will happen if you try to recv() on the same connection from
-//two different threads at the same time.
-//Note that because the vast majority of the routines in this module return
-//a pointer, I have decided to diverge from the rest of Miranda and go with
-//the convention that functions return false on failure and nonzero on success.
+/////////////////////////////////////////////////////////////////////////////////////////
+// this module was created in 0.1.2.2
+// All error codes are returned via GetLastError() (or WSAGetLastError():
+// they're the same).
+// This module is thread-safe where it is sensible for it to be so. This
+// basically means that you can call anything from any thread, but don't try
+// to predict what will happen if you try to recv() on the same connection from
+// two different threads at the same time.
+// Note that because the vast majority of the routines in this module return
+// a pointer, I have decided to diverge from the rest of Miranda and go with
+// the convention that functions return false on failure and nonzero on success.
struct NETLIBHTTPREQUEST_tag;
typedef struct NETLIBHTTPREQUEST_tag NETLIBHTTPREQUEST;
@@ -45,46 +46,48 @@ typedef struct NETLIBOPENCONNECTION_tag NETLIBOPENCONNECTION; #define NETLIB_USER_AGENT "Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Trident/6.0)"
-//Initialises the netlib for a set of connections
-//wParam = 0
-//lParam = (LPARAM)(NETLIBUSER*)&nu
-//Returns a HANDLE to be used for future netlib calls, NULL on failure
-//NOTE: Netlib is loaded after any plugins, so you need to wait until
+/////////////////////////////////////////////////////////////////////////////////////////
+// Initialises the netlib for a set of connections
+// wParam = 0
+// lParam = (LPARAM)(NETLIBUSER*)&nu
+// Returns a HANDLE to be used for future netlib calls, NULL on failure
+// NOTE: Netlib is loaded after any plugins, so you need to wait until
// ME_SYSTEM_MODULESLOADED before calling this function
-//Netlib settings are stored under the module szSettingsModule
-//All netlib settings being with "NL".
-//The default settings for registered users that don't have any settings stored
-//in the database are the same as those displayed by the <All connections> page
-//of the netlib options page.
-//See notes below this function for the behaviour of HTTP gateways
-//Errors: ERROR_INVALID_PARAMETER, ERROR_OUTOFMEMORY, ERROR_DUP_NAME
+// Netlib settings are stored under the module szSettingsModule
+// All netlib settings being with "NL".
+// The default settings for registered users that don't have any settings stored
+// in the database are the same as those displayed by the <All connections> page
+// of the netlib options page.
+// See notes below this function for the behaviour of HTTP gateways
+// Errors: ERROR_INVALID_PARAMETER, ERROR_OUTOFMEMORY, ERROR_DUP_NAME
+
typedef int (*NETLIBHTTPGATEWAYINITPROC)(HANDLE hConn, NETLIBOPENCONNECTION *nloc, NETLIBHTTPREQUEST *nlhr);
typedef int (*NETLIBHTTPGATEWAYBEGINPROC)(HANDLE hConn, NETLIBOPENCONNECTION *nloc);
typedef int (*NETLIBHTTPGATEWAYWRAPSENDPROC)(HANDLE hConn, PBYTE buf, int len, int flags, MIRANDASERVICE pfnNetlibSend);
typedef PBYTE (*NETLIBHTTPGATEWAYUNWRAPRECVPROC)(NETLIBHTTPREQUEST *nlhr, PBYTE buf, int len, int *outBufLen, void *(*NetlibRealloc)(void*, size_t));
typedef struct {
int cbSize;
- char *szSettingsModule; //used for db settings and log
+ char *szSettingsModule; // used for db settings and log
union {
- char *szDescriptiveName; //used in options dialog, already translated
+ char *szDescriptiveName; // used in options dialog, already translated
TCHAR *ptszDescriptiveName;
};
DWORD flags;
char *szHttpGatewayHello;
- char *szHttpGatewayUserAgent; //can be NULL to send no user-agent, also used by HTTPS proxies
+ char *szHttpGatewayUserAgent; // can be NULL to send no user-agent, also used by HTTPS proxies
NETLIBHTTPGATEWAYINITPROC pfnHttpGatewayInit;
- NETLIBHTTPGATEWAYBEGINPROC pfnHttpGatewayBegin; //can be NULL if no beginning required
- NETLIBHTTPGATEWAYWRAPSENDPROC pfnHttpGatewayWrapSend; //can be NULL if no wrapping required
- NETLIBHTTPGATEWAYUNWRAPRECVPROC pfnHttpGatewayUnwrapRecv; //can be NULL if no wrapping required
- int minIncomingPorts; //only if NUF_INCOMING. Will be used for validation of user input.
+ NETLIBHTTPGATEWAYBEGINPROC pfnHttpGatewayBegin; // can be NULL if no beginning required
+ NETLIBHTTPGATEWAYWRAPSENDPROC pfnHttpGatewayWrapSend; // can be NULL if no wrapping required
+ NETLIBHTTPGATEWAYUNWRAPRECVPROC pfnHttpGatewayUnwrapRecv; // can be NULL if no wrapping required
+ int minIncomingPorts; // only if NUF_INCOMING. Will be used for validation of user input.
} NETLIBUSER;
-#define NUF_INCOMING 0x01 //binds incoming ports
-#define NUF_OUTGOING 0x02 //makes outgoing plain connections
-#define NUF_HTTPGATEWAY 0x04 //can use HTTP gateway for plain sockets. ???HttpGateway* are valid. Enables the HTTP proxy option in options.
-#define NUF_NOOPTIONS 0x08 //don't create an options page for this. szDescriptiveName is never used.
-#define NUF_HTTPCONNS 0x10 //at least some connections are made for HTTP communication. Enables the HTTP proxy option in options.
-#define NUF_NOHTTPSOPTION 0x20 //disable the HTTPS proxy option in options. Use this if all communication is HTTP.
-#define NUF_UNICODE 0x40 //if set ptszDescriptiveName points to Unicode, otherwise it points to ANSI string
+#define NUF_INCOMING 0x01 // binds incoming ports
+#define NUF_OUTGOING 0x02 // makes outgoing plain connections
+#define NUF_HTTPGATEWAY 0x04 // can use HTTP gateway for plain sockets. ???HttpGateway* are valid. Enables the HTTP proxy option in options.
+#define NUF_NOOPTIONS 0x08 // don't create an options page for this. szDescriptiveName is never used.
+#define NUF_HTTPCONNS 0x10 // at least some connections are made for HTTP communication. Enables the HTTP proxy option in options.
+#define NUF_NOHTTPSOPTION 0x20 // disable the HTTPS proxy option in options. Use this if all communication is HTTP.
+#define NUF_UNICODE 0x40 // if set ptszDescriptiveName points to Unicode, otherwise it points to ANSI string
#define MS_NETLIB_REGISTERUSER "Netlib/RegisterUser"
#if defined(_UNICODE)
@@ -93,27 +96,27 @@ typedef struct { #define NUF_TCHAR 0
#endif
+/////////////////////////////////////////////////////////////////////////////////////////
+// Assign a Netlib user handle a set of dynamic HTTP headers to be used with all
+//
+// HTTP connections that enable the HTTP-use-sticky headers flag.
+// The headers persist until cleared with lParam = NULL.
+//
+// All memory should be allocated by the caller using malloc() from MS_SYSTEM_GET_MMI
+// Once it has passed to Netlib, Netlib is the owner of it, the caller should not refer to the memory
+// In any way after this point.
+//
+// wParam = (WPARAM)hNetLibUser
+// lParam = (LPARAM)(char*)szHeaders
+//
+// NOTE: The szHeaders parameter should be a NULL terminated string following the HTTP header syntax.
+// This string will be injected verbatim, thus the user should be aware of setting strings that are not
+// headers. This service is NOT THREAD SAFE, only a single thread is expected to set the headers and a single
+// thread reading the pointer internally, stopping race conditions and mutual exclusion don't happen.
+//
+// Version 0.3.2a+ (2003/10/27)
+//
-
-//Assign a Netlib user handle a set of dynamic HTTP headers to be used with all
-//
-//HTTP connections that enable the HTTP-use-sticky headers flag.
-//The headers persist until cleared with lParam = NULL.
-//
-//All memory should be allocated by the caller using malloc() from MS_SYSTEM_GET_MMI
-//Once it has passed to Netlib, Netlib is the owner of it, the caller should not refer to the memory
-//In any way after this point.
-//
-//wParam = (WPARAM)hNetLibUser
-//lParam = (LPARAM)(char*)szHeaders
-//
-//NOTE: The szHeaders parameter should be a NULL terminated string following the HTTP header syntax.
-//This string will be injected verbatim, thus the user should be aware of setting strings that are not
-//headers. This service is NOT THREAD SAFE, only a single thread is expected to set the headers and a single
-//thread reading the pointer internally, stopping race conditions and mutual exclusion don't happen.
-//
-//Version 0.3.2a+ (2003/10/27)
-//
#define MS_NETLIB_SETSTICKYHEADERS "Netlib/SetStickyHeaders"
/* Notes on HTTP gateway usage
@@ -174,14 +177,16 @@ When you call MS_NETLIB_SEND or MS_NETLIB_RECV from any of these functions, you should use the MSG_DUMPPROXY flag so that the logging is neat.
*/
-//Gets the user-configured settings for a netlib user
-//wParam = (WPARAM)(HANDLE)hUser
-//lParam = (LPARAM)(NETLIBUSERSETTINGS*)&nlus
-//Returns nonzero on success, 0 on failure (!! this is different to most of the rest of Miranda, but consistent with netlib)
-//The pointers referred to in the returned struct will remain valid until
-//the hUser handle is closed, or until the user changes the settings in the
-//options page, so it's best not to rely on them for too long.
-//Errors: ERROR_INVALID_PARAMETER
+/////////////////////////////////////////////////////////////////////////////////////////
+// Gets the user-configured settings for a netlib user
+// wParam = (WPARAM)(HANDLE)hUser
+// lParam = (LPARAM)(NETLIBUSERSETTINGS*)&nlus
+// Returns nonzero on success, 0 on failure (!! this is different to most of the rest of Miranda, but consistent with netlib)
+// The pointers referred to in the returned struct will remain valid until
+// the hUser handle is closed, or until the user changes the settings in the
+// options page, so it's best not to rely on them for too long.
+// Errors: ERROR_INVALID_PARAMETER
+
#define PROXYTYPE_SOCKS4 1
#define PROXYTYPE_SOCKS5 2
#define PROXYTYPE_HTTP 3
@@ -205,58 +210,64 @@ typedef struct { int enableUPnP; // 0.6.1+ only for NUF_INCOMING
int validateSSL;
} NETLIBUSERSETTINGS;
+
#define MS_NETLIB_GETUSERSETTINGS "Netlib/GetUserSettings"
-//Changes the user-configurable settings for a netlib user
-//wParam = (WPARAM)(HANDLE)hUser
-//lParam = (LPARAM)(NETLIBUSERSETTINGS*)&nlus
-//Returns nonzero on success, 0 on failure (!! this is different to most of the rest of Miranda, but consistent with netlib)
-//This function is only really useful for people that specify NUF_NOOPTIONS
-//and want to create their own options.
-//Even if a setting is not active (eg szProxyAuthPassword when useProxyAuth is
-//zero) that settings is still set for use in the options dialog.
-//Errors: ERROR_INVALID_PARAMETER
+// Changes the user-configurable settings for a netlib user
+// wParam = (WPARAM)(HANDLE)hUser
+// lParam = (LPARAM)(NETLIBUSERSETTINGS*)&nlus
+// Returns nonzero on success, 0 on failure (!! this is different to most of the rest of Miranda, but consistent with netlib)
+// This function is only really useful for people that specify NUF_NOOPTIONS
+// and want to create their own options.
+// Even if a setting is not active (eg szProxyAuthPassword when useProxyAuth is
+// zero) that settings is still set for use in the options dialog.
+// Errors: ERROR_INVALID_PARAMETER
+
#define MS_NETLIB_SETUSERSETTINGS "Netlib/SetUserSettings"
-//Closes a netlib handle
-//wParam = (WPARAM)(HANDLE)hNetlibHandle
-//lParam = 0
-//Returns nonzero on success, 0 on failure (!! this is different to most of the rest of Miranda, but consistent with netlib)
-//This function should be called on all handles returned by netlib functions
-//once you are done with them. If it's called on a socket-type handle, the
-//socket will be closed.
-//Errors: ERROR_INVALID_PARAMETER
+// Closes a netlib handle
+// wParam = (WPARAM)(HANDLE)hNetlibHandle
+// lParam = 0
+// Returns nonzero on success, 0 on failure (!! this is different to most of the rest of Miranda, but consistent with netlib)
+// This function should be called on all handles returned by netlib functions
+// once you are done with them. If it's called on a socket-type handle, the
+// socket will be closed.
+// Errors: ERROR_INVALID_PARAMETER
#define MS_NETLIB_CLOSEHANDLE "Netlib/CloseHandle"
-__forceinline INT_PTR Netlib_CloseHandle(HANDLE h) {return CallService(MS_NETLIB_CLOSEHANDLE, (WPARAM)h, 0);}
-
-//Open a port and wait for connections on it
-//wParam = (WPARAM)(HANDLE)hUser
-//lParam = (LPARAM)(NETLIBBIND*)&nlb
-//Returns a HANDLE on success, NULL on failure
-//hUser should have been returned by MS_NETLIB_REGISTERUSER
-//This function does the equivalent of socket(), bind(), getsockname(),
-//listen(), accept()
-//Internally this function creates a new thread which waits around in accept()
-//for new connections. When one is received it calls nlb.pfnNewConnection *from
-//this new thread* and then loops back to wait again.
-//Close the returned handle to end the thread and close the open port.
-//Errors: ERROR_INVALID_PARAMETER, any returned by socket() or bind() or
+
+__forceinline INT_PTR Netlib_CloseHandle(HANDLE h)
+{ return CallService(MS_NETLIB_CLOSEHANDLE, (WPARAM)h, 0);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Open a port and wait for connections on it
+// wParam = (WPARAM)(HANDLE)hUser
+// lParam = (LPARAM)(NETLIBBIND*)&nlb
+// Returns a HANDLE on success, NULL on failure
+// hUser should have been returned by MS_NETLIB_REGISTERUSER
+// This function does the equivalent of socket(), bind(), getsockname(),
+// listen(), accept()
+// Internally this function creates a new thread which waits around in accept()
+// for new connections. When one is received it calls nlb.pfnNewConnection *from
+// this new thread* and then loops back to wait again.
+// Close the returned handle to end the thread and close the open port.
+// Errors: ERROR_INVALID_PARAMETER, any returned by socket() or bind() or
// listen() or getsockname()
-//
+//
// Notes:
-//
+//
// During development of 0.3.1a+ (2003/07/04) passing wPort != 0
// will result in an attempt to bind on the port given in wPort
// if this port is taken then you will get an error, so be sure to check
// for such conditions.
-//
+//
// passing wPort != 0 is for people who need to open a set port for
// daemon activities, usually passing wPort == 0 is what you want and
// will result in a free port given by the TCP/IP socket layer and/or
// seeded from the user selected port ranges.
-//
+//
// also note that wPort if != 0, will have be converted to network byte order
-//
+//
/* pExtra was added during 0.3.4+, prior its just two args, since we use the cdecl convention
it shouldnt matter */
@@ -269,32 +280,34 @@ typedef struct { NETLIBNEWCONNECTIONPROC pfnNewConnection;
NETLIBNEWCONNECTIONPROC_V2 pfnNewConnectionV2;
};
- //function to call when there's a new connection. Params are: the
- //new connection, IP of remote machine (host byte order)
- DWORD dwInternalIP; //set on return, host byte order
- WORD wPort; //set on return, host byte order
- void * pExtra; //argument is sent to callback, added during 0.3.4+
- DWORD dwExternalIP; //set on return, host byte order
- WORD wExPort; //set on return, host byte order
+ // function to call when there's a new connection. Params are: the
+ // new connection, IP of remote machine (host byte order)
+ DWORD dwInternalIP; // set on return, host byte order
+ WORD wPort; // set on return, host byte order
+ void * pExtra; // argument is sent to callback, added during 0.3.4+
+ DWORD dwExternalIP; // set on return, host byte order
+ WORD wExPort; // set on return, host byte order
} NETLIBBIND;
+
#define MS_NETLIB_BINDPORT "Netlib/BindPort"
-//Open a connection
-//wParam = (WPARAM)(HANDLE)hUser
-//lParam = (LPARAM)(NETLIBOPENCONNECTION*)&nloc
-//Returns a HANDLE to the new connection on success, NULL on failure
-//hUser must have been returned by MS_NETLIB_REGISTERUSER
-//Internally this function is the equivalent of socket(), gethostbyname(),
-//connect()
-//If NLOCF_HTTP is set and hUser is configured for an HTTP or HTTPS proxy then
-//this function will connect() to the proxy server only, without performing any
-//initialisation conversation.
-//If hUser is configured for an HTTP proxy and does not support HTTP gateways
-//and you try to open a connection without specifying NLOCF_HTTP then this
-//function will first attempt to open an HTTPS connection, if that fails it
-//will try a direct connection, if that fails it will return failure with the
-//error from the connect() during the direct connection attempt.
-//Errors: ERROR_INVALID_PARAMETER, any returned by socket(), gethostbyname(),
+/////////////////////////////////////////////////////////////////////////////////////////
+// Open a connection
+// wParam = (WPARAM)(HANDLE)hUser
+// lParam = (LPARAM)(NETLIBOPENCONNECTION*)&nloc
+// Returns a HANDLE to the new connection on success, NULL on failure
+// hUser must have been returned by MS_NETLIB_REGISTERUSER
+// Internally this function is the equivalent of socket(), gethostbyname(),
+// connect()
+// If NLOCF_HTTP is set and hUser is configured for an HTTP or HTTPS proxy then
+// this function will connect() to the proxy server only, without performing any
+// initialisation conversation.
+// If hUser is configured for an HTTP proxy and does not support HTTP gateways
+// and you try to open a connection without specifying NLOCF_HTTP then this
+// function will first attempt to open an HTTPS connection, if that fails it
+// will try a direct connection, if that fails it will return failure with the
+// error from the connect() during the direct connection attempt.
+// Errors: ERROR_INVALID_PARAMETER, any returned by socket(), gethostbyname(),
// connect(), MS_NETLIB_SEND, MS_NETLIB_RECV, select()
// ERROR_TIMEOUT (during proxy communication)
// ERROR_BAD_FORMAT (very invalid proxy reply)
@@ -308,9 +321,10 @@ typedef struct { // ERROR_INVALID_ADDRESS (socks5 address type not supported)
// HTTP: anything from nlu.pfnHttpGatewayInit, nlu.pfnHttpGatewayBegin,
// MS_NETLIB_SENDHTTPREQUEST or MS_NETLIB_RECVHTTPHEADERS
-#define NLOCF_HTTP 0x0001 //this connection will be used for HTTP communications. If configured for an HTTP/HTTPS proxy the connection is opened as if there was no proxy.
-#define NLOCF_STICKYHEADERS 0x0002 //this connection should send the sticky headers associated with NetLib user apart of any HTTP request
-#define NLOCF_V2 0x0004 //this connection understands the newer structure, newer cbSize isnt enough
+
+#define NLOCF_HTTP 0x0001 // this connection will be used for HTTP communications. If configured for an HTTP/HTTPS proxy the connection is opened as if there was no proxy.
+#define NLOCF_STICKYHEADERS 0x0002 // this connection should send the sticky headers associated with NetLib user apart of any HTTP request
+#define NLOCF_V2 0x0004 // this connection understands the newer structure, newer cbSize isnt enough
#define NLOCF_UDP 0x0008 // this connection is UDP
#define NLOCF_SSL 0x0010 // this connection is SSL
#define NLOCF_HTTPGATEWAY 0x0020 // this connection is HTTP Gateway
@@ -323,8 +337,8 @@ always reached by Windows, If a timeout occurs, or Miranda is exiting then you w struct NETLIBOPENCONNECTION_tag {
int cbSize;
- const char *szHost; //can contain the string representation of an IP
- WORD wPort; //host byte order
+ const char *szHost; // can contain the string representation of an IP
+ WORD wPort; // host byte order
DWORD flags;
unsigned int timeout;
/* optional, called in the context of the thread that issued the attempt, if it returns 0 the connection attempt is
@@ -332,22 +346,21 @@ struct NETLIBOPENCONNECTION_tag { int (*waitcallback) (unsigned int * timeout);
};
-#define NETLIBOPENCONNECTION_V1_SIZE offsetof(NETLIBOPENCONNECTION_tag, timeout) /* old sizeof() is 14 bytes, but there is padding of 2 bytes */
-
-//typedef struct NETLIBOPENCONNECTION_tag NETLIBOPENCONNECTION; //(above for reasons of forward referencing)
#define MS_NETLIB_OPENCONNECTION "Netlib/OpenConnection"
-//Sets the required information for an HTTP proxy connection
-//wParam = (WPARAM)(HANDLE)hConnection
-//lParam = (LPARAM)(NETLIBHTTPPROXYINFO*)&nlhpi
-//Returns nonzero on success, 0 on failure (!! this is different to most of the rest of Miranda, but consistent with netlib)
-//This function is designed to be called from within pfnHttpGatewayInit
-//See notes below MS_NETLIB_REGISTERUSER.
-//Errors: ERROR_INVALID_PARAMETER
-#define NLHPIF_USEGETSEQUENCE 0x0001 //append sequence numbers to GET requests
-#define NLHPIF_USEPOSTSEQUENCE 0x0002 //append sequence numbers to POST requests
-#define NLHPIF_GETPOSTSAMESEQUENCE 0x0004 //GET and POST use the same sequence
-#define NLHPIF_HTTP11 0x0008 //HTTP 1.1 proxy
+/////////////////////////////////////////////////////////////////////////////////////////
+// Sets the required information for an HTTP proxy connection
+// wParam = (WPARAM)(HANDLE)hConnection
+// lParam = (LPARAM)(NETLIBHTTPPROXYINFO*)&nlhpi
+// Returns nonzero on success, 0 on failure (!! this is different to most of the rest of Miranda, but consistent with netlib)
+// This function is designed to be called from within pfnHttpGatewayInit
+// See notes below MS_NETLIB_REGISTERUSER.
+// Errors: ERROR_INVALID_PARAMETER
+
+#define NLHPIF_USEGETSEQUENCE 0x0001 // append sequence numbers to GET requests
+#define NLHPIF_USEPOSTSEQUENCE 0x0002 // append sequence numbers to POST requests
+#define NLHPIF_GETPOSTSAMESEQUENCE 0x0004 // GET and POST use the same sequence
+#define NLHPIF_HTTP11 0x0008 // HTTP 1.1 proxy
typedef struct {
int cbSize;
DWORD flags;
@@ -358,34 +371,40 @@ typedef struct { } NETLIBHTTPPROXYINFO;
#define MS_NETLIB_SETHTTPPROXYINFO "Netlib/SetHttpProxyInfo"
-//Gets the SOCKET associated with a netlib handle
-//wParam = (WPARAM)(HANDLE)hNetlibHandle
-//lParam = 0
-//Returns the SOCKET on success, INVALID_SOCKET on failure
-//hNetlibHandle should have been returned by MS_NETLIB_BINDPORT or
-//MS_NETLIB_OPENCONNECTION only.
-//Be careful how you use this socket because you might be connected via an
-//HTTP proxy in which case calling send() or recv() will totally break things.
-//Errors: ERROR_INVALID_PARAMETER
+/////////////////////////////////////////////////////////////////////////////////////////
+// Gets the SOCKET associated with a netlib handle
+// wParam = (WPARAM)(HANDLE)hNetlibHandle
+// lParam = 0
+// Returns the SOCKET on success, INVALID_SOCKET on failure
+// hNetlibHandle should have been returned by MS_NETLIB_BINDPORT or
+// MS_NETLIB_OPENCONNECTION only.
+// Be careful how you use this socket because you might be connected via an
+// HTTP proxy in which case calling send() or recv() will totally break things.
+// Errors: ERROR_INVALID_PARAMETER
+
#define MS_NETLIB_GETSOCKET "Netlib/GetSocket"
#define Netlib_GetBase64DecodedBufferSize(cchEncoded) (((cchEncoded)>>2)*3)
#define Netlib_GetBase64EncodedBufferSize(cbDecoded) (((cbDecoded)*4+11)/12*4+1)
+/////////////////////////////////////////////////////////////////////////////////////////
// Converts string representation of IP and port into numerical SOCKADDR_INET
// IPv4 could supplied in formats address:port or address
// IPv6 could supplied in formats [address]:port or [address]
// wParam = (WPARAM)(char*) string to convert
// lParam = (LPARAM)(SOCKADDR_INET*) numeric IP address structure
// Returns 0 on success
+
#define MS_NETLIB_STRINGTOADDRESS "Netlib/StringToAddress"
+/////////////////////////////////////////////////////////////////////////////////////////
// Converts numerical representation of IP in SOCKADDR_INET into string representation with IP and port
// IPv4 will be supplied in formats address:port or address
// IPv6 will be supplied in formats [address]:port or [address]
// wParam = (WPARAM)(int)0 - lParam - (sockaddr_gen*); 1 - lParam - (unsigned) in host byte order
// lParam = (LPARAM)(sockaddr_gen*) or (unsigned) numeric IP address structure
// Returns pointer to the string or NULL if not successful
+
#define MS_NETLIB_ADDRESSTOSTRING "Netlib/AddressToString"
typedef struct {
@@ -395,12 +414,14 @@ typedef struct { WORD wPort;
} NETLIBCONNINFO;
+/////////////////////////////////////////////////////////////////////////////////////////
// Get connection Information
// IPv4 will be supplied in formats address:port or address
// IPv6 will be supplied in formats [address]:port or [address]
// wParam = (WPARAM)(HANDLE)hConnection
// lParam = (LPARAM)(NETLIBCONNINFO*) pointer to the connection information structure to fill
// Returns 0 if successful
+
#define MS_NETLIB_GETCONNECTIONINFO "Netlib/GetConnectionInfo"
typedef struct {
@@ -408,28 +429,32 @@ typedef struct { char szIp[1][64];
} NETLIBIPLIST;
+/////////////////////////////////////////////////////////////////////////////////////////
// Get connection Information
// wParam = (WPARAM)IP filter 1 - return global only IPv6 address, 0 all IPs
// Returns (INT_PTR)(NETLIBIPLIST*) numeric IP address address array
// the last element of the array is all 0s, 0 if not successful
+
#define MS_NETLIB_GETMYIP "Netlib/GetMyIP"
-//Send an HTTP request over a connection
-//wParam = (WPARAM)(HANDLE)hConnection
-//lParam = (LPARAM)(NETLIBHTTPREQUEST*)&nlhr
-//Returns number of bytes sent on success, SOCKET_ERROR on failure
-//hConnection must have been returned by MS_NETLIB_OPENCONNECTION
-//Note that if you use NLHRF_SMARTAUTHHEADER and NTLM authentication is in use
-//then the full NTLM authentication transaction occurs, comprising sending the
-//domain, receiving the challenge, then sending the response.
-//nlhr.resultCode and nlhr.szResultDescr are ignored by this function.
-//Errors: ERROR_INVALID_PARAMETER, anything returned by MS_NETLIB_SEND
+/////////////////////////////////////////////////////////////////////////////////////////
+// Send an HTTP request over a connection
+// wParam = (WPARAM)(HANDLE)hConnection
+// lParam = (LPARAM)(NETLIBHTTPREQUEST*)&nlhr
+// Returns number of bytes sent on success, SOCKET_ERROR on failure
+// hConnection must have been returned by MS_NETLIB_OPENCONNECTION
+// Note that if you use NLHRF_SMARTAUTHHEADER and NTLM authentication is in use
+// then the full NTLM authentication transaction occurs, comprising sending the
+// domain, receiving the challenge, then sending the response.
+// nlhr.resultCode and nlhr.szResultDescr are ignored by this function.
+// Errors: ERROR_INVALID_PARAMETER, anything returned by MS_NETLIB_SEND
+
typedef struct {
char *szName;
char *szValue;
} NETLIBHTTPHEADER;
-#define REQUEST_RESPONSE 0 //used by structure returned by MS_NETLIB_RECVHTTPHEADERS
+#define REQUEST_RESPONSE 0 // used by structure returned by MS_NETLIB_RECVHTTPHEADERS
#define REQUEST_GET 1
#define REQUEST_POST 2
#define REQUEST_CONNECT 3
@@ -437,167 +462,211 @@ typedef struct { #define REQUEST_PUT 5
#define REQUEST_DELETE 6
-#define NLHRF_GENERATEHOST 0x00000001 //auto-generate a "Host" header from szUrl
-#define NLHRF_REMOVEHOST 0x00000002 //remove any host and/or protocol portion of szUrl before sending it
-#define NLHRF_SMARTREMOVEHOST 0x00000004 //removes host and/or protocol from szUrl unless the connection was opened through an HTTP or HTTPS proxy.
-#define NLHRF_SMARTAUTHHEADER 0x00000008 //if the connection was opened through an HTTP or HTTPS proxy then send a Proxy-Authorization header if required.
-#define NLHRF_HTTP11 0x00000010 //use HTTP 1.1
-#define NLHRF_PERSISTENT 0x00000020 //preserve connection on exit, open connection provided in the nlc field of the reply
- //it should be supplied in nlc field of request for reuse or closed if not needed
-#define NLHRF_SSL 0x00000040 //use SSL connection
-#define NLHRF_NOPROXY 0x00000080 //do not use proxy server
-#define NLHRF_REDIRECT 0x00000100 //handle HTTP redirect requests (response 30x), the resulting url provided in szUrl of the response
-#define NLHRF_NODUMP 0x00010000 //never dump this to the log
-#define NLHRF_NODUMPHEADERS 0x00020000 //don't dump http headers (only useful for POSTs and MS_NETLIB_HTTPTRANSACTION)
-#define NLHRF_DUMPPROXY 0x00040000 //this transaction is a proxy communication. For dump filtering only.
-#define NLHRF_DUMPASTEXT 0x00080000 //dump posted and reply data as text. Headers are always dumped as text.
-#define NLHRF_NODUMPSEND 0x00100000 //do not dump sent message.
-struct NETLIBHTTPREQUEST_tag {
+#define NLHRF_GENERATEHOST 0x00000001 // auto-generate a "Host" header from szUrl
+#define NLHRF_REMOVEHOST 0x00000002 // remove any host and/or protocol portion of szUrl before sending it
+#define NLHRF_SMARTREMOVEHOST 0x00000004 // removes host and/or protocol from szUrl unless the connection was opened through an HTTP or HTTPS proxy.
+#define NLHRF_SMARTAUTHHEADER 0x00000008 // if the connection was opened through an HTTP or HTTPS proxy then send a Proxy-Authorization header if required.
+#define NLHRF_HTTP11 0x00000010 // use HTTP 1.1
+#define NLHRF_PERSISTENT 0x00000020 // preserve connection on exit, open connection provided in the nlc field of the reply
+ // it should be supplied in nlc field of request for reuse or closed if not needed
+#define NLHRF_SSL 0x00000040 // use SSL connection
+#define NLHRF_NOPROXY 0x00000080 // do not use proxy server
+#define NLHRF_REDIRECT 0x00000100 // handle HTTP redirect requests (response 30x), the resulting url provided in szUrl of the response
+#define NLHRF_NODUMP 0x00010000 // never dump this to the log
+#define NLHRF_NODUMPHEADERS 0x00020000 // don't dump http headers (only useful for POSTs and MS_NETLIB_HTTPTRANSACTION)
+#define NLHRF_DUMPPROXY 0x00040000 // this transaction is a proxy communication. For dump filtering only.
+#define NLHRF_DUMPASTEXT 0x00080000 // dump posted and reply data as text. Headers are always dumped as text.
+#define NLHRF_NODUMPSEND 0x00100000 // do not dump sent message.
+
+struct NETLIBHTTPREQUEST_tag
+{
int cbSize;
- int requestType; //a REQUEST_
+ int requestType; // a REQUEST_
DWORD flags;
char *szUrl;
- NETLIBHTTPHEADER *headers; //If this is a POST request and headers
- //doesn't contain a Content-Length it'll be added automatically
+ NETLIBHTTPHEADER *headers; // If this is a POST request and headers
+ // doesn't contain a Content-Length it'll be added automatically
int headersCount;
- char *pData; //data to be sent in POST request.
- int dataLength; //must be 0 for REQUEST_GET/REQUEST_CONNECT
+ char *pData; // data to be sent in POST request.
+ int dataLength; // must be 0 for REQUEST_GET/REQUEST_CONNECT
int resultCode;
char *szResultDescr;
HANDLE nlc;
int timeout;
};
-#define NETLIBHTTPREQUEST_V1_SIZE (offsetof(NETLIBHTTPREQUEST_tag, timeout))
-//typedef struct NETLIBHTTPREQUEST_tag NETLIBHTTPREQUEST; //(above for reasons of forward referencing)
#define MS_NETLIB_SENDHTTPREQUEST "Netlib/SendHttpRequest"
-//Receive HTTP headers
-//wParam = (WPARAM)(HANDLE)hConnection
-//lParam = 0
-//Returns a pointer to a NETLIBHTTPREQUEST structure on success, NULL on
-//failure.
-//Call MS_NETLIB_FREEHTTPREQUESTSTRUCT to free this.
-//hConnection must have been returned by MS_NETLIB_OPENCONNECTION
-//nlhr->pData = NULL and nlhr->dataLength = 0 always. The requested data should
-//be retrieved using MS_NETLIB_RECV once the header has been parsed.
-//If the headers haven't finished within 60 seconds the function returns NULL
-//and ERROR_TIMEOUT.
-//Errors: ERROR_INVALID_PARAMETER, any from MS_NETLIB_RECV or select()
+/////////////////////////////////////////////////////////////////////////////////////////
+// Receive HTTP headers
+// wParam = (WPARAM)(HANDLE)hConnection
+// lParam = 0
+// Returns a pointer to a NETLIBHTTPREQUEST structure on success, NULL on
+// failure.
+// Call MS_NETLIB_FREEHTTPREQUESTSTRUCT to free this.
+// hConnection must have been returned by MS_NETLIB_OPENCONNECTION
+// nlhr->pData = NULL and nlhr->dataLength = 0 always. The requested data should
+// be retrieved using MS_NETLIB_RECV once the header has been parsed.
+// If the headers haven't finished within 60 seconds the function returns NULL
+// and ERROR_TIMEOUT.
+// Errors: ERROR_INVALID_PARAMETER, any from MS_NETLIB_RECV or select()
// ERROR_HANDLE_EOF (connection closed before headers complete)
// ERROR_TIMEOUT (headers still not complete after 60 seconds)
// ERROR_BAD_FORMAT (invalid character or line ending in headers, or first line is blank)
// ERROR_BUFFER_OVERFLOW (each header line must be less than 4096 chars long)
// ERROR_INVALID_DATA (first header line is malformed ("http/[01].[0-9] [0-9]+ .*", or no colon in subsequent line)
+
#define MS_NETLIB_RECVHTTPHEADERS "Netlib/RecvHttpHeaders"
-//Free the memory used by a NETLIBHTTPREQUEST structure
-//wParam = 0
-//lParam = (LPARAM)(NETLIBHTTPREQUEST*)pnlhr
-//Returns nonzero on success, 0 on failure (!! this is different to most of the rest of Miranda, but consistent with netlib)
-//This should only be called on structures returned by
-//MS_NETLIB_RECVHTTPHEADERS or MS_NETLIB_HTTPTRANSACTION. Calling it on an
-//arbitrary structure will have disastrous results.
-//Errors: ERROR_INVALID_PARAMETER
+/////////////////////////////////////////////////////////////////////////////////////////
+// Free the memory used by a NETLIBHTTPREQUEST structure
+// wParam = 0
+// lParam = (LPARAM)(NETLIBHTTPREQUEST*)pnlhr
+// Returns nonzero on success, 0 on failure (!! this is different to most of the rest of Miranda, but consistent with netlib)
+// This should only be called on structures returned by
+// MS_NETLIB_RECVHTTPHEADERS or MS_NETLIB_HTTPTRANSACTION. Calling it on an
+// arbitrary structure will have disastrous results.
+// Errors: ERROR_INVALID_PARAMETER
+
#define MS_NETLIB_FREEHTTPREQUESTSTRUCT "Netlib/FreeHttpRequestStruct"
-//Do an entire HTTP transaction
-//wParam = (WPARAM)(HANDLE)hUser
-//lParam = (LPARAM)(NETLIBHTTPREQUEST*)&nlhr
-//Returns a pointer to another NETLIBHTTPREQUEST structure on success, NULL on
-//failure.
-//Call MS_NETLIB_FREEHTTPREQUESTSTRUCT to free this.
-//hUser must have been returned by MS_NETLIB_REGISTERUSER
-//nlhr.szUrl should be a full HTTP URL. If it does not start with http://, that
-//will be assumed (but it's best not to use this fact, for reasons of
-//extensibility).
-//This function is the equivalent of MS_NETLIB_OPENCONNECTION,
-//MS_NETLIB_SENDHTTPREQ, MS_NETLIB_RECVHTTPHEADERS, MS_NETLIB_RECV,
-//MS_NETLIB_CLOSEHANDLE
-//nlhr.headers will be augmented with the following headers unless they have
-//already been set by the caller:
+/////////////////////////////////////////////////////////////////////////////////////////
+// smart pointer for NETLIBHTTPREQUEST via a call of MS_NETLIB_FREEHTTPREQUESTSTRUCT
+
+#ifdef __cplusplus
+class NLHR_PTR
+{
+protected:
+ NETLIBHTTPREQUEST *_p;
+
+public:
+ __inline explicit NLHR_PTR(NETLIBHTTPREQUEST *p) : _p(p) {}
+ __inline NETLIBHTTPREQUEST* operator=(NETLIBHTTPREQUEST *p)
+ {
+ if (_p)
+ CallService(MS_NETLIB_FREEHTTPREQUESTSTRUCT, 0, (LPARAM)(NETLIBHTTPREQUEST*)_p);
+ _p = p;
+ return _p;
+ }
+ __inline operator NETLIBHTTPREQUEST*() const { return _p; }
+ __inline NETLIBHTTPREQUEST* operator->() const { return _p; }
+ __inline ~NLHR_PTR()
+ {
+ CallService(MS_NETLIB_FREEHTTPREQUESTSTRUCT, 0, (LPARAM)(NETLIBHTTPREQUEST*)this);
+ }
+};
+#endif
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Do an entire HTTP transaction
+// wParam = (WPARAM)(HANDLE)hUser
+// lParam = (LPARAM)(NETLIBHTTPREQUEST*)&nlhr
+// Returns a pointer to another NETLIBHTTPREQUEST structure on success, NULL on
+// failure.
+// Call MS_NETLIB_FREEHTTPREQUESTSTRUCT to free this.
+// hUser must have been returned by MS_NETLIB_REGISTERUSER
+// nlhr.szUrl should be a full HTTP URL. If it does not start with http:// , that
+// will be assumed (but it's best not to use this fact, for reasons of
+// extensibility).
+// This function is the equivalent of MS_NETLIB_OPENCONNECTION,
+// MS_NETLIB_SENDHTTPREQ, MS_NETLIB_RECVHTTPHEADERS, MS_NETLIB_RECV,
+// MS_NETLIB_CLOSEHANDLE
+// nlhr.headers will be augmented with the following headers unless they have
+// already been set by the caller:
// "Host" (regardless of whether it is requested in nlhr.flags)
// "User-Agent" (of the form "Miranda/0.1.2.2 (alpha)" or "Miranda/0.1.2.2")
// "Content-Length" (for POSTs only. Set to nlhr.dataLength)
-//If you do not want to send one of these headers, create a nlhr.headers with
-//szValue = NULL.
-//In the return value headers, headerCount, pData, dataLength, resultCode and
-//szResultDescr are all valid.
-//In the return value pData[dataLength] == 0 always, as an extra safeguard
-//against programming slips.
-//Note that the function can succeed (ie not return NULL) yet result in an HTTP
-//error code. You should check that resultCode == 2xx before proceeding.
-//Errors: ERROR_INVALID_PARAMETER, ERROR_OUTOFMEMORY, anything from the above
+// If you do not want to send one of these headers, create a nlhr.headers with
+// szValue = NULL.
+// In the return value headers, headerCount, pData, dataLength, resultCode and
+// szResultDescr are all valid.
+// In the return value pData[dataLength] == 0 always, as an extra safeguard
+// against programming slips.
+// Note that the function can succeed (ie not return NULL) yet result in an HTTP
+// error code. You should check that resultCode == 2xx before proceeding.
+// Errors: ERROR_INVALID_PARAMETER, ERROR_OUTOFMEMORY, anything from the above
// list of functions
+
#define MS_NETLIB_HTTPTRANSACTION "Netlib/HttpTransaction"
-//Send data over a connection
-//wParam = (WPARAM)(HANDLE)hConnection
-//lParam = (LPARAM)(NETLIBBUFFER*)&nlb
-//Returns the number of bytes sent on success, SOCKET_ERROR on failure
-//Errors: ERROR_INVALID_PARAMETER
+/////////////////////////////////////////////////////////////////////////////////////////
+// Send data over a connection
+// wParam = (WPARAM)(HANDLE)hConnection
+// lParam = (LPARAM)(NETLIBBUFFER*)&nlb
+// Returns the number of bytes sent on success, SOCKET_ERROR on failure
+// Errors: ERROR_INVALID_PARAMETER
// anything from send(), nlu.pfnHttpGatewayWrapSend()
// HTTP proxy: ERROR_GEN_FAILURE (http result code wasn't 2xx)
// anything from socket(), connect(),
// MS_NETLIB_SENDHTTPREQUEST, MS_NETLIB_RECVHTTPHEADERS
-//flags:
-#define MSG_NOHTTPGATEWAYWRAP 0x010000 //don't wrap the outgoing packet using nlu.pfnHttpGatewayWrapSend
-#define MSG_NODUMP 0x020000 //don't dump this packet to the log
-#define MSG_DUMPPROXY 0x040000 //this is proxy communiciation. For dump filtering only.
-#define MSG_DUMPASTEXT 0x080000 //this is textual data, don't dump as hex
-#define MSG_RAW 0x100000 //send as raw data, bypass any HTTP proxy stuff
-#define MSG_DUMPSSL 0x200000 //this is SSL traffic. For dump filtering only.
+// flags:
+
+#define MSG_NOHTTPGATEWAYWRAP 0x010000 // don't wrap the outgoing packet using nlu.pfnHttpGatewayWrapSend
+#define MSG_NODUMP 0x020000 // don't dump this packet to the log
+#define MSG_DUMPPROXY 0x040000 // this is proxy communiciation. For dump filtering only.
+#define MSG_DUMPASTEXT 0x080000 // this is textual data, don't dump as hex
+#define MSG_RAW 0x100000 // send as raw data, bypass any HTTP proxy stuff
+#define MSG_DUMPSSL 0x200000 // this is SSL traffic. For dump filtering only.
typedef struct {
char *buf;
int len;
int flags;
} NETLIBBUFFER;
+
#define MS_NETLIB_SEND "Netlib/Send"
-static __inline INT_PTR Netlib_Send(HANDLE hConn, const char *buf, int len, int flags) {
+
+__inline INT_PTR Netlib_Send(HANDLE hConn, const char *buf, int len, int flags)
+{
NETLIBBUFFER nlb = {(char*)buf, len, flags};
return CallService(MS_NETLIB_SEND, (WPARAM)hConn, (LPARAM)&nlb);
}
-//Receive data over a connection
-//wParam = (WPARAM)(HANDLE)hConnection
-//lParam = (LPARAM)(NETLIBBUFFER*)&nlb
-//Returns the number of bytes read on success, SOCKET_ERROR on failure,
-//0 if the connection has been closed
-//Flags supported: MSG_PEEK, MSG_NODUMP, MSG_DUMPPROXY, MSG_NOHTTPGATEWAYWRAP,
+/////////////////////////////////////////////////////////////////////////////////////////
+// Receive data over a connection
+// wParam = (WPARAM)(HANDLE)hConnection
+// lParam = (LPARAM)(NETLIBBUFFER*)&nlb
+// Returns the number of bytes read on success, SOCKET_ERROR on failure,
+// 0 if the connection has been closed
+// Flags supported: MSG_PEEK, MSG_NODUMP, MSG_DUMPPROXY, MSG_NOHTTPGATEWAYWRAP,
// MSG_DUMPASTEXT, MSG_RAW
-//On using MSG_NOHTTPGATEWAYWRAP: Because packets through an HTTP proxy are
+// On using MSG_NOHTTPGATEWAYWRAP: Because packets through an HTTP proxy are
// batched and cached and stuff, using this flag is not a guarantee that it
// will be obeyed, and if it is it may even be propogated to future calls
// even if you don't specify it then. Because of this, the flag should be
// considered an all-or-nothing thing: either use it for the entire duration
// of a connection, or not at all.
-//Errors: ERROR_INVALID_PARAMETER, anything from recv()
+// Errors: ERROR_INVALID_PARAMETER, anything from recv()
// HTTP proxy: ERROR_GEN_FAILURE (http result code wasn't 2xx)
-// ERROR_INVALID_DATA (no Content-Length header in reply)
+// ERROR_INVALID_DATA (no Content-Length header in reply)
// ERROR_NOT_ENOUGH_MEMORY (Content-Length very large)
// ERROR_HANDLE_EOF (connection closed before Content-Length bytes recved)
// anything from select(), MS_NETLIB_RECVHTTPHEADERS,
-// nlu.pfnHttpGatewayUnwrapRecv, socket(), connect(),
-// MS_NETLIB_SENDHTTPREQUEST
+// nlu.pfnHttpGatewayUnwrapRecv, socket(), connect(),
+// MS_NETLIB_SENDHTTPREQUEST
+
#define MS_NETLIB_RECV "Netlib/Recv"
-static __inline INT_PTR Netlib_Recv(HANDLE hConn, char *buf, int len, int flags) {
+
+__inline INT_PTR Netlib_Recv(HANDLE hConn, char *buf, int len, int flags)
+{
NETLIBBUFFER nlb = {buf, len, flags};
return CallService(MS_NETLIB_RECV, (WPARAM)hConn, (LPARAM)&nlb);
}
-//Determine the status of one or more connections
-//wParam = 0
-//lParam = (LPARAM)(NETLIBSELECT*)&nls
-//Returns the number of ready connections, SOCKET_ERROR on failure,
-//0 if the timeout expired.
-//All handles passed to this function must have been returned by either
-//MS_NETLIB_OPENCONNECTION or MS_NETLIB_BINDPORT.
-//The last handle in each list must be followed by either NULL or
-//INVALID_HANDLE_VALUE.
-//Errors: ERROR_INVALID_HANDLE, ERROR_INVALID_DATA, anything from select()
+/////////////////////////////////////////////////////////////////////////////////////////
+// Determine the status of one or more connections
+// wParam = 0
+// lParam = (LPARAM)(NETLIBSELECT*)&nls
+// Returns the number of ready connections, SOCKET_ERROR on failure,
+// 0 if the timeout expired.
+// All handles passed to this function must have been returned by either
+// MS_NETLIB_OPENCONNECTION or MS_NETLIB_BINDPORT.
+// The last handle in each list must be followed by either NULL or
+// INVALID_HANDLE_VALUE.
+// Errors: ERROR_INVALID_HANDLE, ERROR_INVALID_DATA, anything from select()
+
typedef struct {
int cbSize;
- DWORD dwTimeout; //in milliseconds, INFINITE is acceptable
+ DWORD dwTimeout; // in milliseconds, INFINITE is acceptable
HANDLE hReadConns[FD_SETSIZE+1];
HANDLE hWriteConns[FD_SETSIZE+1];
HANDLE hExceptConns[FD_SETSIZE+1];
@@ -605,7 +674,7 @@ typedef struct { typedef struct {
int cbSize;
- DWORD dwTimeout; //in milliseconds, INFINITE is acceptable
+ DWORD dwTimeout; // in milliseconds, INFINITE is acceptable
HANDLE hReadConns[FD_SETSIZE+1];
HANDLE hWriteConns[FD_SETSIZE+1];
HANDLE hExceptConns[FD_SETSIZE+1];
@@ -616,93 +685,110 @@ typedef struct { } NETLIBSELECTEX;
#define MS_NETLIB_SELECT "Netlib/Select"
-// added in v0.3.3
#define MS_NETLIB_SELECTEX "Netlib/SelectEx"
-//Shutdown connection
-//wParam = (WPARAM)(HANDLE)hConnection
-//lParam = 0
-//Returns 0
+/////////////////////////////////////////////////////////////////////////////////////////
+// Shutdown connection
+// wParam = (WPARAM)(HANDLE)hConnection
+// lParam = 0
+// Returns 0
+
#define MS_NETLIB_SHUTDOWN "Netlib/Shutdown"
-__forceinline void Netlib_Shutdown(HANDLE h) {CallService(MS_NETLIB_SHUTDOWN, (WPARAM)h, 0);}
-
-//Create a packet receiver
-//wParam = (WPARAM)(HANDLE)hConnection
-//lParam = (LPARAM)(int)maxPacketSize
-//Returns a HANDLE on success, NULL on failure
-//The packet receiver implements the common situation where you have variable
-//length packets coming in over a connection and you want to split them up
-//in order to handle them.
-//The major limitation is that the buffer is created in memory, so you can't
-//have arbitrarily large packets.
-//Errors: ERROR_INVALID_PARAMETER, ERROR_OUTOFMEMORY
+
+__forceinline void Netlib_Shutdown(HANDLE h)
+{
+ CallService(MS_NETLIB_SHUTDOWN, (WPARAM)h, 0);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// Create a packet receiver
+// wParam = (WPARAM)(HANDLE)hConnection
+// lParam = (LPARAM)(int)maxPacketSize
+// Returns a HANDLE on success, NULL on failure
+// The packet receiver implements the common situation where you have variable
+// length packets coming in over a connection and you want to split them up
+// in order to handle them.
+// The major limitation is that the buffer is created in memory, so you can't
+// have arbitrarily large packets.
+// Errors: ERROR_INVALID_PARAMETER, ERROR_OUTOFMEMORY
+
#define MS_NETLIB_CREATEPACKETRECVER "Netlib/CreatePacketRecver"
-//Get the next set of packets from a packet receiver
-//wParam = (WPARAM)(HANDLE)hPacketRecver
-//lParam = (LPARAM)(NETLIBPACKETRECVER*)&nlpr
-//Returns the total number of bytes available in the buffer, 0 if the
-//connection was closed, SOCKET_ERROR on error.
-//hPacketRecver must have been returned by MS_NETLIB_CREATEPACKETRECVER
-//If nlpr.bytesUsed is set to zero and the buffer is already full up to
-//maxPacketSize, it is assumed that too large a packet has been received. All
-//data in the buffer is discarded and receiving is begun anew. This will
-//probably cause alignment problems so if you think this is likely to happen
-//then you should deal with it yourself.
-//Closing the packet receiver will not close the associated connection, but
-//will discard any bytes still in the buffer, so if you intend to carry on
-//reading from that connection, make sure you have processed the buffer first.
-//This function is the equivalent of a memmove() to remove the first bytesUsed
-//from the buffer, select() if dwTimeout is not INFINITE, then MS_NETLIB_RECV.
-//Errors: ERROR_INVALID_PARAMETER, ERROR_TIMEOUT,
+/////////////////////////////////////////////////////////////////////////////////////////
+// Get the next set of packets from a packet receiver
+// wParam = (WPARAM)(HANDLE)hPacketRecver
+// lParam = (LPARAM)(NETLIBPACKETRECVER*)&nlpr
+// Returns the total number of bytes available in the buffer, 0 if the
+// connection was closed, SOCKET_ERROR on error.
+// hPacketRecver must have been returned by MS_NETLIB_CREATEPACKETRECVER
+// If nlpr.bytesUsed is set to zero and the buffer is already full up to
+// maxPacketSize, it is assumed that too large a packet has been received. All
+// data in the buffer is discarded and receiving is begun anew. This will
+// probably cause alignment problems so if you think this is likely to happen
+// then you should deal with it yourself.
+// Closing the packet receiver will not close the associated connection, but
+// will discard any bytes still in the buffer, so if you intend to carry on
+// reading from that connection, make sure you have processed the buffer first.
+// This function is the equivalent of a memmove() to remove the first bytesUsed
+// from the buffer, select() if dwTimeout is not INFINITE, then MS_NETLIB_RECV.
+// Errors: ERROR_INVALID_PARAMETER, ERROR_TIMEOUT,
// anything from select(), MS_NETLIB_RECV
+
typedef struct {
int cbSize;
- DWORD dwTimeout; //fill before calling. In milliseconds. INFINITE is valid
- int bytesUsed; //fill before calling. This many bytes are removed from the start of the buffer. Set to 0 on return
- int bytesAvailable; //equal to the return value, unless the return value is 0
- int bufferSize; //same as parameter to MS_NETLIB_CREATEPACKETRECVER
- BYTE *buffer; //contains the recved data
+ DWORD dwTimeout; // fill before calling. In milliseconds. INFINITE is valid
+ int bytesUsed; // fill before calling. This many bytes are removed from the start of the buffer. Set to 0 on return
+ int bytesAvailable; // equal to the return value, unless the return value is 0
+ int bufferSize; // same as parameter to MS_NETLIB_CREATEPACKETRECVER
+ BYTE *buffer; // contains the recved data
} NETLIBPACKETRECVER;
+
#define MS_NETLIB_GETMOREPACKETS "Netlib/GetMorePackets"
-//Add a message to the log (if it's running)
-//wParam = (WPARAM)(HANDLE)hUser
-//lParam = (LPARAM)(const char *)szMessage
-//Returns nonzero on success, 0 on failure (!! this is different to most of the rest of Miranda, but consistent with netlib)
-//Do not include a final line ending in szMessage.
-//Errors: ERROR_INVALID_PARAMETER
+/////////////////////////////////////////////////////////////////////////////////////////
+// Add a message to the log (if it's running)
+// wParam = (WPARAM)(HANDLE)hUser
+// lParam = (LPARAM)(const char *)szMessage
+// Returns nonzero on success, 0 on failure (!! this is different to most of the rest of Miranda, but consistent with netlib)
+// Do not include a final line ending in szMessage.
+// Errors: ERROR_INVALID_PARAMETER
+
#define MS_NETLIB_LOG "Netlib/Log"
#define MS_NETLIB_LOGW "Netlib/LogW"
-//Sets a gateway polling timeout interval
-//wParam = (WPARAM)(HANDLE)hConn
-//lParam = (LPARAM)timeout
-//Returns previous timeout value
-//Errors: -1
+/////////////////////////////////////////////////////////////////////////////////////////
+// Sets a gateway polling timeout interval
+// wParam = (WPARAM)(HANDLE)hConn
+// lParam = (LPARAM)timeout
+// Returns previous timeout value
+// Errors: -1
+
#define MS_NETLIB_SETPOLLINGTIMEOUT "Netlib/SetPollingTimeout"
-//Makes connection SSL
-//wParam = (WPARAM)(HANDLE)hConn
-//lParam = (LPARAM)(NETLIBSSL*)&nlssl or null if no certficate validation required
-//Returns 0 on failure 1 on success
+/////////////////////////////////////////////////////////////////////////////////////////
+// Makes connection SSL
+// wParam = (WPARAM)(HANDLE)hConn
+// lParam = (LPARAM)(NETLIBSSL*)&nlssl or null if no certficate validation required
+// Returns 0 on failure 1 on success
+
#define MS_NETLIB_STARTSSL "Netlib/StartSsl"
typedef struct
{
int cbSize;
- const char *host; //Expected host name
- int flags; //Reserved
+ const char *host; // Expected host name
+ int flags; // Reserved
} NETLIBSSL;
+/////////////////////////////////////////////////////////////////////////////////////////
+// here's a handy piece of code to let you log using printf-style specifiers:
+// #include <stdarg.h> and <stdio.h> before including this header in order to
+// use it.
-//here's a handy piece of code to let you log using printf-style specifiers:
-//#include <stdarg.h> and <stdio.h> before including this header in order to
-//use it.
#if defined va_start && (defined _STDIO_DEFINED || defined _STDIO_H_) && (!defined NETLIB_NOLOGGING)
#pragma warning(disable:4505)
-static INT_PTR Netlib_Logf(HANDLE hUser, const char *fmt, ...)
+__inline INT_PTR Netlib_Logf(HANDLE hUser, const char *fmt, ...)
{
va_list va;
va_start(va, fmt);
@@ -712,7 +798,7 @@ static INT_PTR Netlib_Logf(HANDLE hUser, const char *fmt, ...) return CallService(MS_NETLIB_LOG, (WPARAM)hUser, (LPARAM)szText);
}
-static INT_PTR Netlib_LogfW(HANDLE hUser, const wchar_t *fmt, ...)
+__inline INT_PTR Netlib_LogfW(HANDLE hUser, const wchar_t *fmt, ...)
{
va_list va;
va_start(va, fmt);
@@ -723,7 +809,7 @@ static INT_PTR Netlib_LogfW(HANDLE hUser, const wchar_t *fmt, ...) }
#define Netlib_LogfT Netlib_LogfW
-#endif //defined va_start
+#endif // defined va_start
/////////////////////////////////////////////////////////////////////////////////////////
// Security providers (0.6+)
@@ -762,16 +848,18 @@ static __inline HANDLE Netlib_InitSecurityProvider2(const TCHAR* szProviderName, return (HANDLE)CallService(MS_NETLIB_INITSECURITYPROVIDER2, 0, (LPARAM)&temp);
}
-
+/////////////////////////////////////////////////////////////////////////////////////////
// Destroys a security provider's handle, provided by Netlib_InitSecurityProvider.
// Right now only NTLM is supported
+
#define MS_NETLIB_DESTROYSECURITYPROVIDER "Netlib/DestroySecurityProvider"
-static __inline void Netlib_DestroySecurityProvider(char* szProviderName, HANDLE hProvider)
+__forceinline void Netlib_DestroySecurityProvider(char* szProviderName, HANDLE hProvider)
{
CallService(MS_NETLIB_DESTROYSECURITYPROVIDER, (WPARAM)szProviderName, (LPARAM)hProvider);
}
+/////////////////////////////////////////////////////////////////////////////////////////
// Returns the NTLM response string. The result value should be freed using mir_free
typedef struct {
@@ -783,7 +871,7 @@ typedef struct { #define MS_NETLIB_NTLMCREATERESPONSE "Netlib/NtlmCreateResponse"
-static __inline char* Netlib_NtlmCreateResponse(HANDLE hProvider, char* szChallenge, char* login, char* psw)
+ __forceinline char* Netlib_NtlmCreateResponse(HANDLE hProvider, char* szChallenge, char* login, char* psw)
{
NETLIBNTLMREQUEST temp = { szChallenge, login, psw };
return (char*)CallService(MS_NETLIB_NTLMCREATERESPONSE, (WPARAM)hProvider, (LPARAM)&temp);
@@ -815,7 +903,7 @@ static __inline char* Netlib_NtlmCreateResponse2(HANDLE hProvider, char* szChall // WARNING: these hooks are being called in the context of the calling thread, without switching
// to the first thread, like all another events do. The hook procedure should be ready for the
// multithreaded mode
-//
+//
// Parameters:
// wParam: NETLIBNOTIFY* - points to the data being sent/received
// lParam: NETLIBUSER* - points to the protocol definition
diff --git a/protocols/SkypeWeb/src/http_request.h b/protocols/SkypeWeb/src/http_request.h index 363ff6ec87..f12a5111b1 100644 --- a/protocols/SkypeWeb/src/http_request.h +++ b/protocols/SkypeWeb/src/http_request.h @@ -264,26 +264,4 @@ public: }
};
-class NLHR_PTR
-{
-protected:
- NETLIBHTTPREQUEST *_p;
-
-public:
- __inline explicit NLHR_PTR(NETLIBHTTPREQUEST *p) : _p(p) {}
- __inline NETLIBHTTPREQUEST* operator=(NETLIBHTTPREQUEST *p)
- {
- if (_p)
- CallService(MS_NETLIB_FREEHTTPREQUESTSTRUCT, 0, (LPARAM)(NETLIBHTTPREQUEST*)_p);
- _p = p;
- return _p;
- }
- __inline operator NETLIBHTTPREQUEST*() const { return _p; }
- __inline NETLIBHTTPREQUEST* operator->() const { return _p; }
- __inline ~NLHR_PTR()
- {
- CallService(MS_NETLIB_FREEHTTPREQUESTSTRUCT, 0, (LPARAM)(NETLIBHTTPREQUEST*)this);
- }
-};
-
#endif //_HTTP_REQUEST_H_
\ No newline at end of file diff --git a/src/modules/netlib/netlibhttp.cpp b/src/modules/netlib/netlibhttp.cpp index cd7a173f1a..3fe48d5dc1 100644 --- a/src/modules/netlib/netlibhttp.cpp +++ b/src/modules/netlib/netlibhttp.cpp @@ -410,12 +410,12 @@ INT_PTR NetlibHttpSendRequest(WPARAM wParam, LPARAM lParam) int bytesSent;
bool lastFirstLineFail = false;
- if (nlhr == NULL || nlhr->cbSize < NETLIBHTTPREQUEST_V1_SIZE || nlhr->szUrl == NULL || nlhr->szUrl[0] == '\0') {
+ if (nlhr == NULL || nlhr->cbSize != sizeof(NETLIBHTTPREQUEST) || nlhr->szUrl == NULL || nlhr->szUrl[0] == '\0') {
SetLastError(ERROR_INVALID_PARAMETER);
return SOCKET_ERROR;
}
- int hdrTimeout = nlhr->cbSize > NETLIBHTTPREQUEST_V1_SIZE && nlhr->timeout ? nlhr->timeout : HTTPRECVHEADERSTIMEOUT;
+ int hdrTimeout = (nlhr->timeout) ? nlhr->timeout : HTTPRECVHEADERSTIMEOUT;
const char *pszRequest;
switch(nlhr->requestType) {
@@ -831,10 +831,9 @@ INT_PTR NetlibHttpTransaction(WPARAM wParam, LPARAM lParam) {
NetlibUser *nlu = (NetlibUser*)wParam;
NETLIBHTTPREQUEST *nlhr = (NETLIBHTTPREQUEST*)lParam, *nlhrReply;
- DWORD dflags, hflags;
if (GetNetlibHandleType(nlu) != NLH_USER || !(nlu->user.flags & NUF_OUTGOING) ||
- nlhr == NULL || nlhr->cbSize < NETLIBHTTPREQUEST_V1_SIZE ||
+ nlhr == NULL || nlhr->cbSize != sizeof(NETLIBHTTPREQUEST) ||
nlhr->szUrl == NULL || nlhr->szUrl[0] == 0)
{
SetLastError(ERROR_INVALID_PARAMETER);
@@ -891,11 +890,11 @@ INT_PTR NetlibHttpTransaction(WPARAM wParam, LPARAM lParam) if (!doneUserAgentHeader || !doneAcceptEncoding)
mir_free(nlhrSend.headers);
- dflags = (nlhr->flags & NLHRF_DUMPASTEXT ? MSG_DUMPASTEXT:0) |
+ DWORD dflags = (nlhr->flags & NLHRF_DUMPASTEXT ? MSG_DUMPASTEXT : 0) |
(nlhr->flags & NLHRF_NODUMP ? MSG_NODUMP : (nlhr->flags & NLHRF_DUMPPROXY ? MSG_DUMPPROXY : 0)) |
(nlhr->flags & NLHRF_NOPROXY ? MSG_RAW : 0);
- hflags =
+ DWORD hflags =
(nlhr->flags & NLHRF_NODUMP ? MSG_NODUMP : (nlhr->flags & NLHRF_DUMPPROXY ? MSG_DUMPPROXY : 0)) |
(nlhr->flags & NLHRF_NOPROXY ? MSG_RAW : 0);
|