//プロジェクト名http001 C++ソースファイルhttp001.cpp リソーススクリプトhttp001.rc ws2_32.lib
#include <stdio.h>
#include <string.h>
#include <io.h>
#include <fcntl.h>
#include <winsock2.h>
#include <process.h>
#include <windows.h>
#include <windowsx.h>
#include <commctrl.h>
#pragma comment(lib, "ws2_32.lib")
extern "C" {
__declspec(dllexport) char * md5checksum(char * string01,char * string02);
__declspec(dllexport) int opensock(char * string01,int port01);
__declspec(dllexport) int sendsock(int sock,char * string01);
__declspec(dllexport) unsigned long sendsockfile(int sock,char * string01, unsigned long length,int timeout);
__declspec(dllexport) int recvsockoneline(int sock,char * string01);
__declspec(dllexport) unsigned long recvsockfile(int sock,char * string01, unsigned long length,int timeout);
__declspec(dllexport) int closesock(int sock);
__declspec(dllexport) char * base64encode(char * string01,char * string02);
BOOL CALLBACK DlgProc(HWND hWnd ,UINT msg ,WPARAM wp,LPARAM lp);
unsigned __stdcall thread01(void *arg);
#define IDD_DIALOG1       101
#define IDC_FILE          1001
#define IDC_BYTE          1002
#define IDC_LENGTH        1003
#define IDC_PROGRESS1     1004
//#define PBM_SETBKCOLOR    0x2001
//#define PBM_SETBARCOLOR   0x409
static char * b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
static HWND hProg1;
HWND hDlg;
MSG msg;
int flag02 = 1;
BOOL CALLBACK DlgProc(HWND hWnd ,UINT msg ,WPARAM wp,LPARAM lp){
	if((msg == WM_CLOSE) || (msg == WM_COMMAND)){
		flag02 = 0;
	}	
	return FALSE;
}
unsigned __stdcall thread01(void *arg)
{
	HINSTANCE hInst = GetModuleHandle("http001.dll");
	hDlg=CreateDialog(hInst, MAKEINTRESOURCE(IDD_DIALOG1), NULL, (DLGPROC)DlgProc);/*ダイアログ作成*/
	ShowWindow( hDlg, SW_SHOW );
	while (flag02 && (GetMessage(&msg, NULL, 0, 0))) {
		if (!IsDialogMessage(hDlg, &msg)){
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}
	DestroyWindow( hDlg );
	return(0);
}
/*
 *  RFC 1321 compliant MD5 implementation
 *
 *  Copyright (C) 2001-2003  Christophe Devine
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#ifndef _MD5_H
#define _MD5_H
#ifndef uint8
#define uint8  unsigned char
#endif
#ifndef uint32
#define uint32 unsigned long int
#endif
typedef struct
{
	uint32 total[2];
	uint32 state[4];
	uint8 buffer[64];
}
md5_context;
void md5_starts( md5_context *ctx );
void md5_update( md5_context *ctx, uint8 *input, uint32 length );
void md5_finish( md5_context *ctx, uint8 digest[16] );
#endif /* md5.h */
#define GET_UINT32(n,b,i)                       \
{                                               \
    (n) = ( (uint32) (b)[(i)    ]       )       \
        | ( (uint32) (b)[(i) + 1] <<  8 )       \
        | ( (uint32) (b)[(i) + 2] << 16 )       \
        | ( (uint32) (b)[(i) + 3] << 24 );      \
}
#define PUT_UINT32(n,b,i)                       \
{                                               \
    (b)[(i)    ] = (uint8) ( (n)       );       \
    (b)[(i) + 1] = (uint8) ( (n) >>  8 );       \
    (b)[(i) + 2] = (uint8) ( (n) >> 16 );       \
    (b)[(i) + 3] = (uint8) ( (n) >> 24 );       \
}
void md5_starts( md5_context *ctx )
{
    ctx->total[0] = 0;
    ctx->total[1] = 0;
    ctx->state[0] = 0x67452301;
    ctx->state[1] = 0xEFCDAB89;
    ctx->state[2] = 0x98BADCFE;
    ctx->state[3] = 0x10325476;
}
void md5_process( md5_context *ctx, uint8 data[64] )
{
    uint32 X[16], A, B, C, D;
    GET_UINT32( X[0],  data,  0 );
    GET_UINT32( X[1],  data,  4 );
    GET_UINT32( X[2],  data,  8 );
    GET_UINT32( X[3],  data, 12 );
    GET_UINT32( X[4],  data, 16 );
    GET_UINT32( X[5],  data, 20 );
    GET_UINT32( X[6],  data, 24 );
    GET_UINT32( X[7],  data, 28 );
    GET_UINT32( X[8],  data, 32 );
    GET_UINT32( X[9],  data, 36 );
    GET_UINT32( X[10], data, 40 );
    GET_UINT32( X[11], data, 44 );
    GET_UINT32( X[12], data, 48 );
    GET_UINT32( X[13], data, 52 );
    GET_UINT32( X[14], data, 56 );
    GET_UINT32( X[15], data, 60 );
#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
#define P(a,b,c,d,k,s,t)                                \
{                                                       \
    a += F(b,c,d) + X[k] + t; a = S(a,s) + b;           \
}
    A = ctx->state[0];
    B = ctx->state[1];
    C = ctx->state[2];
    D = ctx->state[3];
#define F(x,y,z) (z ^ (x & (y ^ z)))
    P( A, B, C, D,  0,  7, 0xD76AA478 );
    P( D, A, B, C,  1, 12, 0xE8C7B756 );
    P( C, D, A, B,  2, 17, 0x242070DB );
    P( B, C, D, A,  3, 22, 0xC1BDCEEE );
    P( A, B, C, D,  4,  7, 0xF57C0FAF );
    P( D, A, B, C,  5, 12, 0x4787C62A );
    P( C, D, A, B,  6, 17, 0xA8304613 );
    P( B, C, D, A,  7, 22, 0xFD469501 );
    P( A, B, C, D,  8,  7, 0x698098D8 );
    P( D, A, B, C,  9, 12, 0x8B44F7AF );
    P( C, D, A, B, 10, 17, 0xFFFF5BB1 );
    P( B, C, D, A, 11, 22, 0x895CD7BE );
    P( A, B, C, D, 12,  7, 0x6B901122 );
    P( D, A, B, C, 13, 12, 0xFD987193 );
    P( C, D, A, B, 14, 17, 0xA679438E );
    P( B, C, D, A, 15, 22, 0x49B40821 );
#undef F
#define F(x,y,z) (y ^ (z & (x ^ y)))
    P( A, B, C, D,  1,  5, 0xF61E2562 );
    P( D, A, B, C,  6,  9, 0xC040B340 );
    P( C, D, A, B, 11, 14, 0x265E5A51 );
    P( B, C, D, A,  0, 20, 0xE9B6C7AA );
    P( A, B, C, D,  5,  5, 0xD62F105D );
    P( D, A, B, C, 10,  9, 0x02441453 );
    P( C, D, A, B, 15, 14, 0xD8A1E681 );
    P( B, C, D, A,  4, 20, 0xE7D3FBC8 );
    P( A, B, C, D,  9,  5, 0x21E1CDE6 );
    P( D, A, B, C, 14,  9, 0xC33707D6 );
    P( C, D, A, B,  3, 14, 0xF4D50D87 );
    P( B, C, D, A,  8, 20, 0x455A14ED );
    P( A, B, C, D, 13,  5, 0xA9E3E905 );
    P( D, A, B, C,  2,  9, 0xFCEFA3F8 );
    P( C, D, A, B,  7, 14, 0x676F02D9 );
    P( B, C, D, A, 12, 20, 0x8D2A4C8A );
#undef F
#define F(x,y,z) (x ^ y ^ z)
    P( A, B, C, D,  5,  4, 0xFFFA3942 );
    P( D, A, B, C,  8, 11, 0x8771F681 );
    P( C, D, A, B, 11, 16, 0x6D9D6122 );
    P( B, C, D, A, 14, 23, 0xFDE5380C );
    P( A, B, C, D,  1,  4, 0xA4BEEA44 );
    P( D, A, B, C,  4, 11, 0x4BDECFA9 );
    P( C, D, A, B,  7, 16, 0xF6BB4B60 );
    P( B, C, D, A, 10, 23, 0xBEBFBC70 );
    P( A, B, C, D, 13,  4, 0x289B7EC6 );
    P( D, A, B, C,  0, 11, 0xEAA127FA );
    P( C, D, A, B,  3, 16, 0xD4EF3085 );
    P( B, C, D, A,  6, 23, 0x04881D05 );
    P( A, B, C, D,  9,  4, 0xD9D4D039 );
    P( D, A, B, C, 12, 11, 0xE6DB99E5 );
    P( C, D, A, B, 15, 16, 0x1FA27CF8 );
    P( B, C, D, A,  2, 23, 0xC4AC5665 );
#undef F
#define F(x,y,z) (y ^ (x | ~z))
    P( A, B, C, D,  0,  6, 0xF4292244 );
    P( D, A, B, C,  7, 10, 0x432AFF97 );
    P( C, D, A, B, 14, 15, 0xAB9423A7 );
    P( B, C, D, A,  5, 21, 0xFC93A039 );
    P( A, B, C, D, 12,  6, 0x655B59C3 );
    P( D, A, B, C,  3, 10, 0x8F0CCC92 );
    P( C, D, A, B, 10, 15, 0xFFEFF47D );
    P( B, C, D, A,  1, 21, 0x85845DD1 );
    P( A, B, C, D,  8,  6, 0x6FA87E4F );
    P( D, A, B, C, 15, 10, 0xFE2CE6E0 );
    P( C, D, A, B,  6, 15, 0xA3014314 );
    P( B, C, D, A, 13, 21, 0x4E0811A1 );
    P( A, B, C, D,  4,  6, 0xF7537E82 );
    P( D, A, B, C, 11, 10, 0xBD3AF235 );
    P( C, D, A, B,  2, 15, 0x2AD7D2BB );
    P( B, C, D, A,  9, 21, 0xEB86D391 );
#undef F
    ctx->state[0] += A;
    ctx->state[1] += B;
    ctx->state[2] += C;
    ctx->state[3] += D;
}
void md5_update( md5_context *ctx, uint8 *input, uint32 length )
{
    uint32 left, fill;
    if( ! length ) return;
    left = ctx->total[0] & 0x3F;
    fill = 64 - left;
    ctx->total[0] += length;
    ctx->total[0] &= 0xFFFFFFFF;
    if( ctx->total[0] < length )
        ctx->total[1]++;
    if( left && length >= fill )
    {
        memcpy( (void *) (ctx->buffer + left),
                (void *) input, fill );
        md5_process( ctx, ctx->buffer );
        length -= fill;
        input  += fill;
        left = 0;
    }
    while( length >= 64 )
    {
        md5_process( ctx, input );
        length -= 64;
        input  += 64;
    }
    if( length )
    {
        memcpy( (void *) (ctx->buffer + left),
                (void *) input, length );
    }
}
static uint8 md5_padding[64] =
{
 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
void md5_finish( md5_context *ctx, uint8 digest[16] )
{
    uint32 last, padn;
    uint32 high, low;
    uint8 msglen[8];
    high = ( ctx->total[0] >> 29 )
         | ( ctx->total[1] <<  3 );
    low  = ( ctx->total[0] <<  3 );
    PUT_UINT32( low,  msglen, 0 );
    PUT_UINT32( high, msglen, 4 );
    last = ctx->total[0] & 0x3F;
    padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
    md5_update( ctx, md5_padding, padn );
    md5_update( ctx, msglen, 8 );
    PUT_UINT32( ctx->state[0], digest,  0 );
    PUT_UINT32( ctx->state[1], digest,  4 );
    PUT_UINT32( ctx->state[2], digest,  8 );
    PUT_UINT32( ctx->state[3], digest, 12 );
}
/*
 * those are the standard RFC 1321 test vectors
 */
static char *val[] =
{
    "d41d8cd98f00b204e9800998ecf8427e",
    "0cc175b9c0f1b6a831c399e269772661",
    "900150983cd24fb0d6963f7d28e17f72",
    "f96b697d7cb7938d525a2f31aaf161d0",
    "c3fcd3d76192e4007dfb496cca67e13b",
    "d174ab98d277d9f5a5611c2c9f419d9f",
    "57edf4a22be3c955ac49da2e2107b67a"
};
char * md5checksum(char * string01,char * string02)
{
	FILE *f;
	int i, j, len;
	char result[33];
	char * pd=(char *)result;
	md5_context ctx;
	unsigned char buf[1000];
	unsigned char md5sum[16];
	if(  ( f = fopen( string01, "rb" ) ) )
	{
		md5_starts( &ctx );
		while( ( i = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
		{
			md5_update( &ctx, buf, i );
		}
		md5_finish( &ctx, md5sum );
		for( j = 0; j < 16; j++ )
		{
			sprintf(pd,"%02x", md5sum[j]);
			pd +=2;
		}
		* pd='\0';
		len=strlen(string02);
		if (len>=33)
		{
			memcpy(string02,result,33);
		}
		else
		{
			* string02='\0';
		}
	}
	else
	{
		* string02='\0';
	}
	return string02;
}
int opensock(char * string01,int port01)
{
	WSADATA wsaData;
	struct sockaddr_in server;
	SOCKET sock;
	char *deststr;
	unsigned int **addrptr;
	deststr = string01;
	if (WSAStartup(MAKEWORD(2,0), &wsaData) != 0)
//	if (WSAStartup(MAKEWORD(1,1), &wsaData) != 0)
	{
		return(-1);
	}
	sock = socket(AF_INET, SOCK_STREAM, 0);
	if (sock == INVALID_SOCKET)
	{
		return(-1);
	}
	server.sin_family = AF_INET;
	server.sin_port = htons(port01);
	server.sin_addr.S_un.S_addr = inet_addr(deststr);
	if (server.sin_addr.S_un.S_addr == 0xffffffff)
	{
		struct hostent *host;
		host = gethostbyname(deststr);
		if (host == NULL)
		{
			return(-1);
		}
		addrptr = (unsigned int **)host->h_addr_list;
		while (*addrptr != NULL)
		{
			server.sin_addr.S_un.S_addr = *(*addrptr);
			if (connect(sock,(struct sockaddr *)&server,sizeof(server)) == 0)
			{
				break;
			}
			addrptr++;
		}
		if (*addrptr == NULL)
		{
			 return(-1);
		}
	}
	else
	{
		if (connect(sock,(struct sockaddr *)&server,sizeof(server)) != 0)
		{
			return(-1);
		}
	}
	return sock;
}
int sendsock(int sock,char * string01)
{
	fd_set fds, readfds;
	struct timeval tv;
	int result;
	FD_ZERO(&readfds);
	FD_SET((unsigned)sock, &readfds);
	tv.tv_sec = 10;
	tv.tv_usec = 0;
	memcpy(&fds, &readfds, sizeof(fd_set));
	result = select(sock+1, NULL, &fds, NULL, &tv);
	if (result <= 0)
	{
		return(-1);
	}
	int n = send(sock, string01,(int)strlen(string01), 0);
	if (n < 0)
	{
		return(-1);
	}
	return(n);
}
unsigned long sendsockfile(int sock,char * string01, unsigned long length,int timeout)
{
	flag02 = 1;
	fd_set fds, readfds;
	struct timeval tv;
	int result;
	FD_ZERO(&readfds);
	FD_SET((unsigned)sock, &readfds);
	if (timeout>=1 && timeout<=300)
		tv.tv_sec = timeout;
	else
		tv.tv_sec = 10;
	tv.tv_usec = 0;
	FILE * fp01;
	unsigned long read_size,n;
	char* buf     = (char*)calloc(256 , sizeof(char));
	n=0;
	HANDLE thread_id1;
	unsigned	dummy;
	char dlg_file[40], dlg_byte[20], dlg_length[40];
	thread_id1 = (HANDLE)_beginthreadex( NULL, 0, &thread01, NULL, 0, &dummy );
	wsprintf(dlg_file, "%s%s", string01,"をアップロードしています");
	wsprintf(dlg_length, "／    %8d      Byte", length);
	_sleep(200);
	SetWindowText(hDlg,"アップロード");
	Static_SetText(GetDlgItem(hDlg, IDC_FILE), dlg_file);
	Static_SetText(GetDlgItem(hDlg, IDC_LENGTH), dlg_length);
	hProg1 = GetDlgItem(hDlg, IDC_PROGRESS1); 
	SendMessage(hProg1, PBM_SETRANGE, 0, MAKELPARAM(0, 100));
	SendMessage(hProg1, PBM_SETBKCOLOR, 0, (LPARAM)RGB(250, 250, 250));
	SendMessage(hProg1, PBM_SETBARCOLOR, 0, (LPARAM)RGB(0, 255, 0));
	if((fp01=fopen(string01,"rb"))==NULL)
	{
		return(-1);
	}
	int bar01=0;
	while(flag02 && length>n)
	{
		bar01=100*n/length;
		SendMessage(hProg1, PBM_SETPOS, bar01, 0);
		memcpy(&fds, &readfds, sizeof(fd_set));
		result = select(sock+1, NULL, &fds, NULL, &tv);
		if (result <= 0)
		{
			break;
		}
		if((read_size = fread(buf,1, 252, fp01)) > 0)
		{
			send(sock, buf,read_size, 0);
			n+=read_size;
		}
		else
		{
			break;
		}
		wsprintf(dlg_byte, "%8d", n);
		Static_SetText(GetDlgItem(hDlg, IDC_BYTE), dlg_byte);
	}
	_sleep(200);
	SendMessage(hDlg, WM_CLOSE, 0, 0);
	_sleep(400);
	fclose(fp01);
	free(buf);
	CloseHandle( thread_id1 );
	if (n < 0)
	{
		return(-1);
	}
	return(n);
}
int recvsockoneline(int sock,char * string01)
{
	fd_set fds, readfds;
	struct timeval tv;
	int result;
	FD_ZERO(&readfds);
	FD_SET((unsigned)sock, &readfds);
	tv.tv_sec = 10;
	tv.tv_usec = 0;
	char * buf;
	int	len,size,pos,n;
	char c;
	size=0;
	buf=NULL;
	pos=0;
	while(1)
	{
		memcpy(&fds, &readfds, sizeof(fd_set));
		result = select(sock+1, &fds, NULL, NULL, &tv);
		if (result <= 0)
		{
			break;
		}
		c='\0';
		len=recv(sock,&c,1,0);
		if((len<=0) || (pos>4000))
		{
			return(-1);
		}
		if(pos+1>=size)
		{
			size+=4096;
			if(buf==NULL)
			{
				buf=(char *)calloc(size,sizeof(char));
			}
			else
			{
				buf=(char *)realloc(buf,size*sizeof(char));
			}
		}
		buf[pos]=c;
		pos++;
		if(pos>=1&&buf[pos-1]=='\n')
		{
			if(pos>=2&&buf[pos-2]=='\r')
			{
				buf[pos-2]='\0';
				pos-=2;
				break;
			}
			else{
				buf[pos-1]='\0';
				pos--;
				break;
			}
		}
	}
	len=strlen(string01);
	if(buf==NULL)
	{
		return(-1);
	}
	else
	{
		n=strlen(buf);
		if (len>=(n+1))
		{
			memcpy(string01,buf,n+1);
		}
		else
		{
//			* string01='\0';
			pos=0;
		}
	}
	free(buf);
	return(pos);
}
unsigned long recvsockfile(int sock,char * string01, unsigned long length,int timeout)
{
	flag02 = 1;
	fd_set fds, readfds;
	struct timeval tv;
	int result;
	FD_ZERO(&readfds);
	FD_SET((unsigned)sock, &readfds);
	if (timeout>=1 && timeout<=300)
		tv.tv_sec = timeout;
	else
		tv.tv_sec = 10;
	tv.tv_usec = 0;
	FILE * fp01;
	unsigned long read_size,n;
	char* buf     = (char*)calloc(256 , sizeof(char));
	n=0;
	HANDLE thread_id1;
	unsigned	dummy;
	char dlg_file[40], dlg_byte[20], dlg_length[40];
	thread_id1 = (HANDLE)_beginthreadex( NULL, 0, &thread01, NULL, 0, &dummy );
	wsprintf(dlg_file, "%s%s", string01,"にダウンロードしています");
	wsprintf(dlg_length, "／    %8d      Byte", length);
	_sleep(200);
	SetWindowText(hDlg,"ダウンロード");
	Static_SetText(GetDlgItem(hDlg, IDC_FILE), dlg_file);
	Static_SetText(GetDlgItem(hDlg, IDC_LENGTH), dlg_length);
	hProg1 = GetDlgItem(hDlg, IDC_PROGRESS1); 
	SendMessage(hProg1, PBM_SETRANGE, 0, MAKELPARAM(0, 100));
	SendMessage(hProg1, PBM_SETBKCOLOR, 0, (LPARAM)RGB(250, 250, 250));
	SendMessage(hProg1, PBM_SETBARCOLOR, 0, (LPARAM)RGB(0, 255, 0));
	if((fp01=fopen(string01,"wb"))==NULL)
	{
		return(-1);
	}
	int bar01=0;
	while(flag02 && length>n)
	{
		bar01=100*n/length;
		SendMessage(hProg1, PBM_SETPOS, bar01, 0);
		memcpy(&fds, &readfds, sizeof(fd_set));
		result = select(sock+1, &fds, NULL, NULL, &tv);
		if (result <= 0)
		{
			break;
		}
		if((read_size = recv(sock, buf, 252, 0)) > 0)
		{
			fwrite(buf, 1, read_size, fp01);
			n+=read_size;
		}
		wsprintf(dlg_byte, "%8d", n);
		Static_SetText(GetDlgItem(hDlg, IDC_BYTE), dlg_byte);
	}
	_sleep(200);
	SendMessage(hDlg, WM_CLOSE, 0, 0);
	_sleep(400);
	fclose(fp01);
	free(buf);
	CloseHandle( thread_id1 );
	if (n < 0)
	{
		return(-1);
	}
	return(n);
}
int closesock(int sock)
{
	shutdown(sock,2);
	int n = closesocket(sock);
	WSACleanup();
	return(n);
}
char * base64encode(char * string01,char * string02)
{
	char *param;
	int	size,len,n,done;
	done = FALSE;
	int    i, j;
	int    cnt = 0;
	int    pos = 0;
	int    wk  = 0;
	if(string01 != NULL)
	{
		size = strlen(string01);
		param = (char *)calloc(size*2 + 2,1);
		if (param != NULL)
		{
			char *  p   = param;
			for(i=0 ; i<size ; i++)
			{
				wk <<= 8;
				wk |= (string01[i] & 0xff);
				if( pos == 2 )    // 3byte
				{
					for(j=3 ; j>=0 ; j--)
					{
						*p = b64[(wk>>(6*j)) & 0x3f];
						p++;
						if( ++cnt == 76 )    // MIME
						{
							*p  = '\r';
							p++;
							*p  = '\n';
							p++;
							cnt = 0;
						}
					}
					wk  = 0;
					pos = 0;
				}
				else
					pos++;
			}
			if( pos >= 1 )
			{
				for(i=0 ; i<(3-pos) ; i++)
					wk <<= 8;
				for(j=3 ; j>=0 ; j--)
				{
					if( (3-pos) <= j )
						*p = b64[(wk>>(6*j)) & 0x3f];
					else
						*p = '=';
					p++;
					if( ++cnt == 76 )
					{
						*p  = '\r';
						p++;
						*p  = '\n';
						p++;
						cnt = 0;
					}
				}
			}
			*p = '\0';
			done = TRUE;
		}
	}
	if (done)
	{
		len=strlen(string02);
		n=strlen(param);
		if (len>=n+1)
		{
			memcpy(string02,param,n+1);
		}
		else
		{
			* string02='\0';
		}
	}
	else
	{
		* string02='\0';
	}
	free(param);
	return string02;
}
}