connect.c

g729 coding ipaddressing

/*

	Window procedure for connection MDI window
	
*/

#include "netfone.h"

#define ASYNC_OUTPUT
                            
static struct {
	char header[4];
	unsigned short len, ilen;
	soundbuf sbm;
} mb = {{1, 2, 3, 4}};
#define sb	mb.sbm

soundbuf ebuf;				  		  // Utility sound buffer
static LONG pktlen;					  // Packet length to transmit
static struct adpcm_state adpcm;	  // ADPCM compression state
static int squelched = FALSE;		  // Squelched by VOX ?
static int sqpacket = FALSE;		  // Is this packet squelched
static char ourSendingHost[16];		  // Host name for sound buffer sendinghost
static int xseq = 0;				  // Robust mode transmit sequence number

char blankit[] = "                                                              "
				 "                                                              "
				 "                                                              ";

/*  GSMCOMP  --  Compress the contents of a sound buffer using GSM.  */

static void gsmcomp(soundbuf *asb)
{
    gsm_signal src[160];
    gsm_frame dst;
    int i, j, l = 0;
    char *dp = (asb->buffer.buffer_val) + sizeof(short);
    long ldata = asb->buffer.buffer_len; 
    
    for (i = 0; i < ldata; i += 160) {
        for (j = 0; j < 160; j++) {
            if ((i + j) < asb->buffer.buffer_len) {
                src[j] = audio_u2s(asb->buffer.buffer_val[i + j]);
            } else {
                src[j] = 0;
            }
        }
        gsm_encode(gsmh, src, dst);
        memcpy(dp, dst, sizeof dst);
        dp += sizeof dst;
        l += sizeof dst;
    }

    /* Hide original uncompressed buffer length in first 2 bytes of buffer. */
    
    *((short *) asb->buffer.buffer_val) = (short) ldata;
    revshort((short *) asb->buffer.buffer_val);
    asb->buffer.buffer_len = l + sizeof(short);
}

/*	ADPCMCOMP  --  Compress the contents of a sound buffer using ADPCM.  */

static void adpcmcomp(soundbuf *asb)
{
	unsigned char *dp = (unsigned char *) asb->buffer.buffer_val;
	struct adpcm_state istate;

	istate = adpcm;
	adpcm_coder_u(dp, (char *) dp, (int) asb->buffer.buffer_len, &adpcm);
	asb->buffer.buffer_len /= 2;

	/* Hide the ADPCM encoder state at the end of this buffer.
	   The shifting and anding makes the code byte-order
	   insensitive. */

	dp += asb->buffer.buffer_len;
	*dp++ = ((unsigned int) istate.valprev) >> 8;
	*dp++ = istate.valprev & 0xFF;
	*dp = istate.index;
	asb->buffer.buffer_len += 3;
}

/*	LPCCOMP  --  Compress the contents of a sound buffer using LPC.  */

static void lpccomp(soundbuf *asb)
{
	int i, l = 0;
	char *dp = ((char *) asb->buffer.buffer_val) + sizeof(short);
	unsigned char *src = ((unsigned char *) asb->buffer.buffer_val);
	lpcparams_t lp;

	asb->compression |= fCompLPC;
	for (i = 0; i < asb->buffer.buffer_len; i += LPC_FRAME_SIZE) {
		lpc_analyze(src + i, &lp);
		memcpy(dp, &lp, sizeof lp);
		dp += sizeof lp;
		l += sizeof lp;
	}

	// Hide original uncompressed buffer length in first 2 bytes of buffer.

	*((short *) asb->buffer.buffer_val) = (short) asb->buffer.buffer_len;
	revshort((short *) asb->buffer.buffer_val);
	asb->buffer.buffer_len = l + sizeof(short);
}

/*	LPC10COMP  --  Compress the contents of a sound buffer using LPC-10.  */

static void lpc10comp(soundbuf *asb)
{
	char *dp = (char *) asb->buffer.buffer_val;
	unsigned char *src = ((unsigned char *) asb->buffer.buffer_val);

	asb->compression |= fCompLPC10;
	asb->buffer.buffer_len = lpc10encode(src, dp, asb->buffer.buffer_len);
}

/*	LPC10STUFF	--	Stuff last 16 bytes of LPC10 packet in sendinghost. */

static int lpc10stuff(struct soundbuf *asb, int pktlen)
{
	if ((asb->compression & fCompLPC10) && (asb->buffer.buffer_len > 16)) {
		memcpy(asb->sendinghost, 
			((char *) asb) + (pktlen - (sizeof asb->sendinghost)),
			sizeof asb->sendinghost);
		pktlen -= sizeof asb->sendinghost;
	}
	return pktlen;
}

/*	LPC10UNSTUFF  --  Reverse the effect of lpc10stuff. */

static void lpc10unstuff(struct soundbuf *asb)
{
	if ((asb->compression & fCompLPC10) && (asb->buffer.buffer_len > 16)) {
		pktlen += sizeof asb->sendinghost;
	}
}

/*	CELPCOMP  --  Compress the contents of a sound buffer using CELP.  */

static void celpcomp(struct soundbuf *asb)
{
	short src[240];
	char celp_frame[18];
	int i, j, l = 0;
	char *dp = ((char *) asb->buffer.buffer_val) + sizeof(short);

	asb->compression |= fCompCELP;
	for (i = 0; i < asb->buffer.buffer_len; i += 240) {
		for (j = 0; j < 240; j++) {
			if ((i + j) < asb->buffer.buffer_len) {
				src[j] = audio_u2s(asb->buffer.buffer_val[i + j]);
			} else {
				src[j] = 0;
			}
		}
#ifdef CELP_USE_CONTEXT
		/* Allocate and initialise the CELP transmit encoding context the first time
		   we need to encode audio. */
		if (celp_xp == NULL) {
			celp_xp = (struct celp_context *) GlobalAllocPtr(GPTR, sizeof(struct celp_context));
			if (celp_xp == NULL) {
				return;
			}
			celp_context_init(celp_xp);
			celp_init(celp_xp, FALSE);
		}
		celp_encode(celp_xp, src, celp_frame);
#else
		celp_encode(src, celp_frame);
#endif
		memcpy(dp, celp_frame, sizeof celp_frame);
		dp += sizeof celp_frame;
		l += sizeof celp_frame;
	}

	/* Hide original uncompressed buffer length in first 2 bytes of buffer. */
	
	*((short *) asb->buffer.buffer_val) = htons((short) asb->buffer.buffer_len);
	asb->buffer.buffer_len = l + sizeof(short);
}

/*	CELPSTUFF	--	Stuff last 16 bytes of CELP packet in sendinghost. */

static int celpstuff(struct soundbuf *asb, int pktlen)
{
	if ((asb->compression & fCompCELP) && (asb->buffer.buffer_len > 16)) {
		memcpy(asb->sendinghost, ((char *) asb) + (pktlen - (sizeof asb->sendinghost)),
			sizeof asb->sendinghost);
		pktlen -= sizeof asb->sendinghost;
	}
	return pktlen;
}

/*	CELPUNSTUFF  --  Reverse the effect of celpstuff. */

static void celpunstuff(struct soundbuf *asb)
{
	if ((asb->compression & fCompCELP) && (asb->buffer.buffer_len > 16)) {
		pktlen += sizeof asb->sendinghost;
	}
}

/*  COMPRESS2X  --  Compress a sound buffer with Simple (discard every
					other sample) compression.  If you're doing both
					Simple and GSM compression, Simple compression must be
					done first.  */
					
void compress2X(soundbuf *asb)
{
#ifdef OLD2X
    LONG i;
	         
    asb->buffer.buffer_len /= 2;
    for (i = 1; i < asb->buffer.buffer_len; i++) {
        asb->buffer.buffer_val[i] = asb->buffer.buffer_val[i * 2];
    }
#else
	int li = (int) asb->buffer.buffer_len;
	int lo = li / 2;
	
	rate_flow(&xrate, (unsigned char *) asb->buffer.buffer_val,
			  (unsigned char *) asb->buffer.buffer_val,
			  &li, &lo);
	asb->buffer.buffer_len = lo; 
#endif
}

/*	AES_cbc_encrypt  --  Encrypt buffer with AES.  Cipher block
						 chaining is done within each buffer.  */
						 
void AES_cbc_encrypt(unsigned char *in,
					 unsigned char *out,
					 int len, aes_ctx *ctx)
{
	int i, j;
	unsigned char feedback[AES_BLOCK_SIZE];
	
	//	Initially zero the feedback buffer.
	memset(feedback, 0, AES_BLOCK_SIZE);
	Assert((len % AES_BLOCK_SIZE) == 0);		// Attempt to encrypt non-multiple of block length
	
	//	Loop over encryption blocks in the buffer.
	for (i = 0; i < len; i += AES_BLOCK_SIZE) {
		/*	XOR the next block to be encrypted with the
			last encrypted block.  */
		for (j = 0; j < AES_BLOCK_SIZE; j++) {
			in[j] ^= feedback[j];
		}
		//	Encrypt the block.
		aes_enc_blk(in, out, ctx);
		//	Save encrypted block in feedback to XOR with next.
		memcpy(feedback, out, AES_BLOCK_SIZE);
		//	Advance input and output pointers to next block.
		in += AES_BLOCK_SIZE;
		out += AES_BLOCK_SIZE;
	}
}

/*	MONITORPORT  --  Obtain an auxiliary socket to receive input
					 from a given port.  Existing sockets are reused
					 and their reference count incremented.  */

static struct auxSocket *monitorPort(unsigned short port)
{
	struct auxSocket *as = asList;
	WORD serr = 0;

	while (as != NULL) {
		if (port == as->asport) {
			break;
		}
		as = as->asnext;
	}
	
	if (as == NULL) {
#ifdef TRACE_AUX_SOCKET
OutputDebugString("Allocating aux socket.\r\n");
#endif	
		as = (struct auxSocket *) GlobalAllocPtr(GPTR, sizeof(struct auxSocket));
		if (as != NULL) {
			as->asnext = asList;
			asList = as;
			as->asrefc = 0;
			as->asport = port;
			as->asdata = as->asctrl = INVALID_SOCKET;
		}
	}
	if (as != NULL) {
		if (as->asrefc == 0) {
		    serr = CreateSocket(&(as->asdata), SOCK_DGRAM,
		    		htonl(INADDR_ANY), htons(as->asport));
			if (serr != 0) {
		        MsgBox(NULL, MB_ICONSTOP | MB_OK, Format(73),
		                port, serr, SockerrToString(serr));
		        goto bang;
			}
		    serr = CreateSocket(&(as->asctrl), SOCK_DGRAM,
		    		htonl(INADDR_ANY), htons((short) (as->asport + 1)));
			if (serr != 0) {
		        MsgBox(NULL, MB_ICONSTOP | MB_OK, Format(73),
		                port + 1, serr, SockerrToString(serr));
		        goto bang;
			}
#ifdef ASYNC_OUTPUT			
		    if (WSAAsyncSelect(as->asdata, hwndMDIFrame, WM_SOCKET_SELECT, FD_READ) != 0) {
		        serr = WSAGetLastError();
		    }
			if (serr != 0) {
		        MsgBox(NULL, MB_ICONSTOP | MB_OK, Format(73),
		                port, serr, SockerrToString(serr));
		        goto bang;
			}
		    if (WSAAsyncSelect(as->asctrl, hwndMDIFrame, WM_SOCKET_CONTROL, FD_READ) != 0) {
		        serr = WSAGetLastError();
		    }
			if (serr != 0) {
		        MsgBox(NULL, MB_ICONSTOP | MB_OK, Format(73),
		                port + 1, serr, SockerrToString(serr));
		        goto bang;
			}
#endif			
#ifdef TRACE_AUX_SOCKET
OutputDebugString("Opened aux socket.\r\n");
#endif
#ifdef IP_MAX_MEMBERSHIPS			
			multicastJoin(hwndMDIFrame, FALSE);
			multicastJoin(hwndMDIFrame, TRUE);
#endif						
		}
		as->asrefc++;
	}
	return as;
	
bang:
	if (as->asdata != INVALID_SOCKET) {
		closesocket(as->asdata);
		as->asdata = INVALID_SOCKET;
	}
	if (as->asctrl != INVALID_SOCKET) {
		closesocket(as->asctrl);
		as->asctrl = INVALID_SOCKET;
	}
	return NULL;
}

//	WRITEOUTPUT  --  Transmit output buffer to destination

static int writeOutput(LPCLIENT_DATA d, LPSTR buf, int buflen)
{
#ifdef MODEM
	if (d->modemConnection) {
		if (modemHandle != -1) {
			unsigned short bcrc;
			COMSTAT cs;
			int wrl, err;
		
			mb.len = (unsigned short) buflen;
			mb.ilen = ~mb.len;
			revshort(&mb.len);
			revshort(&mb.ilen);
			bcrc = crc((LPSTR) &mb, buflen + 4 + 2 * sizeof(unsigned short));
			revshort(&bcrc);
			err = GetCommError(modemHandle, &cs);
			if (err != 0) { 
				MsgBox(hwndMDIFrame, MB_ICONSTOP | MB_OK, Format(20), err);
				errorRant(hwndMDIFrame);
				return -1;
			} 
			wrl = WriteComm(modemHandle, &mb, buflen + 4 + 2 * sizeof(unsigned short));
			err = GetCommError(modemHandle, &cs);
			if (err != 0) { 
				MsgBox(hwndMDIFrame, MB_ICONSTOP | MB_OK, Format(21), err);
				errorRant(hwndMDIFrame);
				return -1;
			} 
			if (wrl > 0) {
				wrl = WriteComm(modemHandle, &bcrc, sizeof(short));
			}
			err = GetCommError(modemHandle, &cs);
			if (err != 0) { 
				MsgBox(hwndMDIFrame, MB_ICONSTOP | MB_OK, Format(22), err);
				errorRant(hwndMDIFrame);
				return -1;
			}
			return buflen;
		}
	} else
#endif	
	if (d->outputSocketBusy) {
		propeller(IDC_PH_OUTPUT_LOST, ++outputPacketsLost);
#ifdef OVERLOAD			
OutputDebugString("Socket busy--packet discarded.\r\n");
#endif
		return buflen;					
	} else {
		int stat, wasSentTo = FALSE;
		
#ifdef OVERLOAD
	int OL;
	for (OL = 0; OL < OVERLOAD; OL++) {
#endif