lwl.c

IP网络语音通讯软件源代码. 不可多得的语音源代码

/*

	Look Who's Listening dialogue handlers

*/

#include "netfone.h"

struct sockaddr_in lookhost;   		// Look who's listening host, if any

//  EDITRETURN  --  Edit control which notifies parent of return key. 

static WNDPROC lpfnOldEdit = NULL;

#define WM_EDITRETURN	(WM_USER + 1002) 

LONG WINAPI editReturn(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{

	if (message == WM_GETDLGCODE) {
		return DLGC_WANTALLKEYS;		// We want to see Tab, Return, etc.
	}

	if ((message == WM_KEYDOWN && wParam == VK_TAB) ||
		(message == WM_KEYDOWN && wParam == VK_RETURN)) {
		if ((lParam & (1 << 31)) == 0) {
			SendMessage(GetParent(hWnd), WM_COMMAND,
				MAKELONG(GetWindowLong(hWnd, GWL_ID), WM_EDITRETURN),
				(LPARAM) hWnd);
		}
		return 0L;
	} else {
		return CallWindowProc(lpfnOldEdit, hWnd, message, wParam, lParam);
	}
}

/*	SENDLWLMESSAGE	--	If enabled, send a message identifying us
                        to the selected Look Who's Listening server.  */

int sendLwlMessage(HWND hDlg, int dobye)
{
	int sock;

	sock = socket(AF_INET, SOCK_STREAM, 0);
	if (sock == INVALID_SOCKET) {
        int serr = WSAGetLastError();
						            
        MsgBox(hDlg, MB_ICONSTOP | MB_OK, Format(54),
                serr, SockerrToString(serr));
		return FALSE;
	}
	if (connect(sock, (struct sockaddr *) &(lookhost), sizeof lookhost) >= 0) {
		if (dobye) {
			char v[128];
			int l;

            l = rtp_make_bye(v, ssrc, rstring(IDS_T_RAISON_EXITING), FALSE);
			if (send(sock, v, l, 0) < 0) {
		        int serr = WSAGetLastError();
								            
		        MsgBox(hDlg, MB_ICONSTOP | MB_OK, Format(55),
		                serr, SockerrToString(serr));
		        closesocket(sock);
				return FALSE;
			}
		} else {
			if (send(sock, (char *) sdes, sdesl, 0) < 0) {
		        int serr = WSAGetLastError();
								            
		        MsgBox(hDlg, MB_ICONSTOP | MB_OK, Format(56),
		                serr, SockerrToString(serr));
		        closesocket(sock);
				return FALSE;
			}
		}
	} else {
        int serr = WSAGetLastError();
								            
        MsgBox(hDlg, MB_ICONSTOP | MB_OK, Format(57),
                serr, SockerrToString(serr));
        closesocket(sock);
		return FALSE;
	}
	closesocket(sock);
	return TRUE;
}

//	LWL_RECONNECT  --  Reconnect to current Look Who's Listening server

int lwl_reconnect(HWND hDlg)
{
	lwl_t_published = FALSE;
    if (lwl_s_server[0] == 0 || lwl_s_email[0] == 0) {
    	lwl_s_publish = FALSE;
    }
						
	//	Remake session identity information
					
	if (sdes != NULL) {
		free(sdes);
		sdes = NULL;
	}
	if (lwl_s_email[0] != 0) {
		sdesl = rtp_make_sdes(&sdes, ssrc, NETFONE_COMMAND_PORT,
							  lwl_s_exact, FALSE);
	}
	if (rtpsdes != NULL) {
		free(rtpsdes);
		rtpsdes = NULL;
	}
	rtpsdesl = rtp_make_sdes(&rtpsdes, ssrc, NETFONE_COMMAND_PORT,
							 FALSE, TRUE);
	if (vatid != NULL) {
		free(vatid);
		vatid = NULL;
	}
	vatidl = makeVATid(&vatid, 0L);
					
	/*	If the user wishes to publish this information, look
		up the host where it's to be published.  */
					
	if (lwl_s_publish) {
		lookhost.sin_family = AF_INET;
		lookhost.sin_port = htons(NETFONE_COMMAND_PORT + 2);
		lookhost.sin_addr.s_addr = inet_addr(lwl_s_server);
		if (lookhost.sin_addr.s_addr == INADDR_NONE) {
			LPHOSTENT h = gethostbyname(lwl_s_server);
							
			if (h == NULL) {
	            int serr = WSAGetLastError();
						            
		        MsgBox(hDlg, MB_ICONSTOP | MB_OK, Format(41),
		                (LPSTR) lwl_s_server,
		                serr, SockerrToString(serr));
		        return FALSE;
			} else {
				_fmemcpy(&lookhost.sin_addr.s_addr, (h->h_addr),
					sizeof lookhost.sin_addr.s_addr);
			}
		}
		if (lwl_t_pending) {
			lwl_t_pending = 2;
		} else {
			lwl_t_resend = 2;				// Set to resend in two seconds
		}
		lwl_t_published = lwl_s_publish;
	}
	return TRUE;
}

//	LWL_TELL_PROC  --  Look Who's Listening publish dialogue procedure

BOOL CALLBACK lwl_tell_proc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	static int serverDefault;

    switch (message) {
        case WM_INITDIALOG:
        	{
				CheckDlgButton(hDlg, IDC_LWLS_UNLISTED, lwl_s_publish);
				CheckDlgButton(hDlg, IDC_LWLS_EXACT, lwl_s_exact);
				if ((serverDefault = (lwl_s_server[0] == 0)) != 0) {
					SetDlgItemText(hDlg, IDC_LWLS_SERVER, rstring(IDS_T_LWL_DEFAULT_SERVER));
				} else {
					SetDlgItemText(hDlg, IDC_LWLS_SERVER, lwl_s_server);
				}
				SetDlgItemText(hDlg, IDC_LWLS_EMAIL, lwl_s_email);
				SetDlgItemText(hDlg, IDC_LWLS_FULLNAME, lwl_s_fullname);
				SetDlgItemText(hDlg, IDC_LWLS_PHONE, lwl_s_phone);
				SetDlgItemText(hDlg, IDC_LWLS_LOCATION, lwl_s_location);
			}
            break;

        case WM_COMMAND:
            switch ((short) WM_COMMAND_ID(wParam)) {
                case IDOK:
                
                	/* If information is currently published, revoke it in
                	   case we're about to publish a changed version. */
                	   
                	if (lwl_t_published && !lwl_t_pending) {
                		sendLwlMessage(hDlg, TRUE);		// Send BYE message
                		lwl_t_published = FALSE;
                	}
                
                	lwl_s_publish = IsDlgButtonChecked(hDlg, IDC_LWLS_UNLISTED);
                	lwl_s_exact = IsDlgButtonChecked(hDlg, IDC_LWLS_EXACT);
                	if (!serverDefault) {
						GetDlgItemText(hDlg, IDC_LWLS_SERVER, lwl_s_server, sizeof lwl_s_server);
					}
					GetDlgItemText(hDlg, IDC_LWLS_EMAIL, lwl_s_email, sizeof lwl_s_email);
					GetDlgItemText(hDlg, IDC_LWLS_FULLNAME, lwl_s_fullname, sizeof lwl_s_fullname);
					GetDlgItemText(hDlg, IDC_LWLS_PHONE, lwl_s_phone, sizeof lwl_s_phone);
					GetDlgItemText(hDlg, IDC_LWLS_LOCATION, lwl_s_location, sizeof lwl_s_location);
					if (lwl_reconnect(hDlg)) {
	                	EndDialog(hDlg, TRUE);
	                }
                    break;

                case IDCANCEL:
                    EndDialog(hDlg, FALSE);
                    break;
                    
                case IDC_LWLS_SERVER:
                	if (WM_COMMAND_NOTIFY == EN_CHANGE) {
                		serverDefault = FALSE;
                	}
                	break;
		        	
                case ID_HELP:
                	WinHelp(hwndMDIFrame, rstring(IDS_HELPFILE), HELP_KEY,
                				((DWORD) (Lrstring(IDS_HELP_LWL_TELL))));
                	holped = TRUE;
                	break;

                default:
                    break;
            }
            break;
        	
        default:
        	break;	    	
    }
    return FALSE;
}

//	LWL_TELL_SETTINGS  --  Set Look Who's Listening published properties

VOID lwl_tell_settings(HWND hwnd)
{
    DialogBox(hInst, MAKEINTRESOURCE(IDD_LWL_TELL), hwnd, lwl_tell_proc);
    return;
}

struct lwl {
	struct lwl FAR *next;				// Next connection
	long ltime;							// Time of last update
	unsigned long ssrc;					// Session source descriptor
	long naddr;							// Internet address
	unsigned short port;				// Port address
	LPSTR cname;						// Canonical name 
	LPSTR name;							// User name
	LPSTR email;						// Electronic mail address
	LPSTR phone;						// Telephone number
	LPSTR loc;							// Geographic location
	LPSTR tool;							// Application name
};

static struct lwl FAR *conn;			// Connection chain
static struct lwl FAR *ctail;			// Connection chain tail
static int diasel = -1;					// Selected item in results box

/*	DUPSDESITEM  --  Make a copy of an SDES item and advance the pointer
					 past it.  */

static LPSTR dupSdesItem(char **cp)
{
	char *ip = *cp;
	int l = ip[1];
	LPSTR bp;

	bp = GlobalAllocPtr(GPTR, l + 1);
	if (bp != NULL) {
		_fmemcpy(bp, ip + 2, l);
		bp[l] = 0;
	}
	*cp = ip + l + 2;
	return bp;
}

//	DESTROYLWL	--	Release storage associated with an LWL list item.

static void destroyLwl(struct lwl FAR *lw)
{
	if (lw->cname != NULL) {
		GlobalFreePtr(lw->cname);
	}
	if (lw->name != NULL) {
		GlobalFreePtr(lw->name);
	}
	if (lw->email != NULL) {
		GlobalFreePtr(lw->email);
	}
	if (lw->phone != NULL) {
		GlobalFreePtr(lw->phone);
	}
	if (lw->loc != NULL) {
		GlobalFreePtr(lw->loc);
	}
	if (lw->tool != NULL) {
		GlobalFreePtr(lw->tool);
	}
	GlobalFreePtr(lw);
}

//	FREELWLCHAIN  --  Release all items in LWL chain

static void freeLwlChain(void)
{
	while (conn != NULL) {
		struct lwl FAR *co = conn;
		
		conn = co->next;
		destroyLwl(co);
	}
}

//	LWLITEM  --  Get LWL chain item by zero-based index

static struct lwl FAR *lwlItem(int i)
{
	struct lwl FAR *co = conn;

	while (co != NULL && i-- > 0) {
		co = co->next;
	}
	return co;
}

//  ENABLE_ASK_INPUTS  --  Enable/Disable Look Who's Listening query requests

static void enable_ask_inputs(HWND hDlg, int enable)
{
#define EnableD(x) EnableWindow(GetDlgItem(hDlg, x), enable)
	EnableD(IDC_LWLA_SERVER);
	EnableD(IDC_LWLA_QUERY);
	EnableD(IDC_LWLA_SEARCH);
	EnableD(IDOK);
}

#define nTextItems	5

//	UPDATESERVERMESSAGE  --  Update server message on initial connect or server change

static void updateServerMessage(HWND hDlg)
{
	struct sockaddr_in askhost;
	char sv[512];
	char *serv = sv, *cp;
//	rtcp_t *rp = (rtcp_t *) sv;
	SOCKET sock;
	int l;

	enable_ask_inputs(hDlg, FALSE);                	    
    GetDlgItemText(hDlg, IDC_LWLA_SERVER, sv, sizeof sv);
    if (sv[0] == '(') {
    	serv++;
    	if ((cp = strchr(serv, ')')) != NULL) {
    		*cp = 0;
    	}
    }
	askhost.sin_family = AF_INET;
	askhost.sin_port = htons(NETFONE_COMMAND_PORT + 2);
	askhost.sin_addr.s_addr = inet_addr(serv);
	if (askhost.sin_addr.s_addr == INADDR_NONE) {
		LPHOSTENT h;

		SendDlgItemMessage(hDlg, IDC_LWLA_RESULTS, LB_RESETCONTENT, 0, 0L);
		SendDlgItemMessage(hDlg, IDC_LWLA_RESULTS, LB_ADDSTRING, 0,
							(LPARAM) (LPCSTR) rstring(IDS_T_LWLA_LOOKUP));
		h = gethostbyname(serv);
		if (h == NULL) {
            int serr = WSAGetLastError();
			
			if (serr != WSAEINTR) {							            
	        	MsgBox(hDlg, MB_ICONSTOP | MB_OK, Format(41),
	                	(LPSTR) serv,
	                	serr, SockerrToString(serr));
	        }
			SendDlgItemMessage(hDlg, IDC_LWLA_RESULTS, LB_RESETCONTENT, 0, 0L);
			enable_ask_inputs(hDlg, TRUE);                	    
	        return;
		} else {
			_fmemcpy(&askhost.sin_addr.s_addr, (h->h_addr),
				sizeof askhost.sin_addr.s_addr);
		}
	}

	// Create the socket and connect to host
				
	SendDlgItemMessage(hDlg, IDC_LWLA_RESULTS, LB_ADDSTRING, 0,
						(LPARAM) (LPCSTR) rstring(IDS_T_LWLA_CONNECT));
	sock = socket(AF_INET, SOCK_STREAM, 0);
	if (sock == INVALID_SOCKET) {
        int serr = WSAGetLastError();
											            
        MsgBox(hDlg, MB_ICONSTOP | MB_OK, Format(54),
                serr, SockerrToString(serr));
		SendDlgItemMessage(hDlg, IDC_LWLA_RESULTS, LB_RESETCONTENT, 0, 0L);
		enable_ask_inputs(hDlg, TRUE);                	    
		return;
	}
				
	if (connect(sock, (struct sockaddr *) &askhost, sizeof askhost) < 0) {
        int serr = WSAGetLastError();
													            
        MsgBox(hDlg, MB_ICONSTOP | MB_OK, Format(57),
                serr, SockerrToString(serr));
        closesocket(sock);
		SendDlgItemMessage(hDlg, IDC_LWLA_RESULTS, LB_RESETCONTENT, 0, 0L);
		enable_ask_inputs(hDlg, TRUE);                	    
        return;
	}
	*((short *) sv) = (short) ((RTP_VERSION << 14) | RTCP_APP | (1 << 8));
	*((long *) (sv + 4)) = 0;
	_fmemcpy(sv + 8, rstring(IDS_T_LWL_GETMESSAGE), 4);
	*((short *) (sv + 2)) = 2;	// Message length in 32 bit words - 1
	revshort((short *) sv);
	revshort((short *) (sv + 2));
	SendDlgItemMessage(hDlg, IDC_LWLA_RESULTS, LB_ADDSTRING, 0,
						(LPARAM) (LPCSTR) rstring(IDS_T_LWLA_REQUEST));
	if (send(sock, sv, 12, 0) < 0) {
		SendDlgItemMessage(hDlg, IDC_LWLA_RESULTS, LB_RESETCONTENT, 0, 0L);
		enable_ask_inputs(hDlg, TRUE);                	    
        return;
	}
	SendDlgItemMessage(hDlg, IDC_LWLA_RESULTS, LB_ADDSTRING, 0,
							(LPARAM) (LPCSTR) rstring(IDS_T_RECEIVE));
	if ((l = recv(sock, sv, sizeof sv, 0)) <= 0) {
		SendDlgItemMessage(hDlg, IDC_LWLA_RESULTS, LB_RESETCONTENT, 0, 0L);
		enable_ask_inputs(hDlg, TRUE);                	    
        return;
	}
	closesocket(sock);			// Don't need socket any more
	
	SendDlgItemMessage(hDlg, IDC_LWLA_RESULTS, LB_RESETCONTENT, 0, 0L);
	diasel = -1;
	freeLwlChain();
	cp = sv + 12;
	while (cp != NULL) {