Example #1
0
char *QuoteCharsInStr(char *Buffer, const char *String, const char *QuoteChars)
{
char *RetStr=NULL;
const char *sptr, *cptr;
size_t olen=0;

RetStr=CopyStr(Buffer,"");
if (! String) return(RetStr);

for (sptr=String; *sptr !='\0'; sptr++)
{
	for (cptr=QuoteChars; *cptr !='\0'; cptr++)
	{
  	if (*sptr==*cptr)
		{
			RetStr=AddCharToBuffer(RetStr,olen, '\\');
			olen++;
			break;
		}
	}
	RetStr=AddCharToBuffer(RetStr,olen,*sptr);
	olen++;
}

return(RetStr);
}
Example #2
0
char *HTTPQuoteChars(char *RetBuff, char *Str, char *CharList)
{
char *RetStr=NULL, *Token=NULL, *ptr;
int olen=0, ilen;

RetStr=CopyStr(RetStr,"");
ilen=StrLen(Str);

for (ptr=Str; ptr < (Str+ilen); ptr++)
{
if (strchr(CharList,*ptr))
{
		Token=FormatStr(Token,"%%%02X",*ptr); 
		RetStr=CatStr(RetStr,Token);
		olen+=StrLen(Token);
}
else
{
		 RetStr=AddCharToBuffer(RetStr,olen,*ptr); 
		 olen++;
}
}


RetStr[olen]='\0';
DestroyString(Token);
return(RetStr);
}
Example #3
0
char *PadStr(char*Dest, char Pad, int PadLen)
{
char *NewStr=NULL;
int i, len, abslen;

if (PadLen==0) return(Dest);
if (PadLen < 0) abslen=0-PadLen;
else abslen=PadLen;

for (i=0; i < abslen; i++) NewStr=AddCharToBuffer(NewStr,i,Pad);

if (PadLen > 0) 
{
	Dest=(CatStr(Dest, NewStr));
  DestroyString(NewStr);
}
//Negative values mean pad in front of text
else 
{
  NewStr=CatStr(NewStr,Dest);
  //NewStr is the replacement for Dest, so we destroy Dest
  DestroyString(Dest);
	Dest=NewStr;
}

return(Dest);
}
Example #4
0
char *HTTPUnQuote(char *RetBuff, char *Str)
{
char *RetStr=NULL, *Token=NULL, *ptr;
int olen=0, ilen;

RetStr=CopyStr(RetStr,"");
ilen=StrLen(Str);

for (ptr=Str; ptr < (Str+ilen); ptr++)
{
switch (*ptr)
{
	case '+': 
		RetStr=AddCharToBuffer(RetStr,olen,' '); 
		olen++; 
		break;
		
	case '%':
		  ptr++;
		  Token=CopyStrLen(Token,ptr,2); 
		  ptr++; //not +=2, as we will increment again
		  RetStr=AddCharToBuffer(RetStr,olen,strtol(Token,NULL,16) & 0xFF); 
		  olen++; 
		  break;

	default:
		  RetStr=AddCharToBuffer(RetStr,olen,*ptr); 
		  olen++;
		  break;
}

}

DestroyString(Token);
return(RetStr);
}
void NetworkCommandBuffer::Think()
{
	SDLNet_SocketSet set;

	set = SDLNet_AllocSocketSet ( 1 );
	if ( !set )
	{
		RaiseSocketError ( "SDLNet_AllocSocketSet" );
	}
	SocketSetEncapsulator free_on_quit ( set );
	if ( SDLNet_TCP_AddSocket ( set, socket ) < 0 )
		{
			RaiseSocketError ( "SDLNet_TCP_AddSocket" );
		}
	int numready = SDLNet_CheckSockets ( set, 0 );
	for ( ; numready == 1; numready = SDLNet_CheckSockets ( set, 0 ) )
		{
			char msg;
			int nbread = SDLNet_TCP_Recv ( socket, &msg, 1 );
			if ( nbread < 0 )
			{
				RaiseSocketError ( "SDLNet_TCP_Recv: " );
			}
			else if ( nbread == 0 )
			{
				std::cout << "SDLNet_TCP_Recv: Unexpected read of size 0\n";
				throw ReadSocketError();
			}
			if ( debug_all_message )
			{
				if ( msg < 32 )
					std::cout << "Read: 0x" << ( int ) msg << "\n";
				else
					std::cout << "Read: " << msg << "\n";
			}
			if (current_command_size > 0)
				AddCharToBuffer ( msg );
			else
				AddCharToCommandSize( msg );
		}
	if ( numready < 0 )
	{
		std::cout << "SDLNet_CheckSockets: " << SDLNet_GetError() << "\n";
		perror ( "SDLNet_CheckSockets" );
		throw ReadSocketError();
	}
}
Example #6
0
char *TerminalReadText(char *RetStr, int Flags, STREAM *S)
{
int inchar, len=0;
char outchar;

inchar=STREAMReadChar(S);
while (inchar != EOF)
{
	if (Flags & TERM_SHOWTEXT) outchar=inchar & 0xFF;
	if (Flags & TERM_SHOWSTARS) 
	{
		if ((outchar & 0xFF) =='\n') outchar=inchar & 0xFF;
		else if ((outchar & 0xFF) =='\b') outchar=inchar & 0xFF;
		else outchar='*';
	}


	if (Flags & TERM_SHOWTEXTSTARS) 
	{
		switch (inchar)
		{

		case '\n':
		case '\r':
		case 0x08:
		break;

		default:
		if (len > 0) STREAMWriteString("\x08*",S);
		break;
		}

		outchar=inchar & 0xFF;
	}


	STREAMWriteBytes(S, &outchar,1);
	STREAMFlush(S);
	if (inchar == '\n') break;
	if (inchar == '\r') break;

	RetStr=AddCharToBuffer(RetStr,len++, inchar & 0xFF);
	inchar=STREAMReadChar(S);
}

return(RetStr);
}
Example #7
0
char *EnquoteStr(char *Out, const char *In)
{
const char *ptr;
char *ReturnStr=NULL;
size_t len=0;

ptr=In;
ReturnStr=CopyStr(Out,"");

while (ptr && (*ptr != '\0'))
{
	switch (*ptr)
	{
		case '\\':
		case '"':
		case '\'':
		ReturnStr=AddCharToBuffer(ReturnStr,len,'\\');
		len++;
		ReturnStr=AddCharToBuffer(ReturnStr,len, *ptr);
		len++;
		break;


		case '\r':
		ReturnStr=AddCharToBuffer(ReturnStr,len,'\\');
		len++;
		ReturnStr=AddCharToBuffer(ReturnStr,len, 'r');
		len++;
		break;
		
		
		case '\n':
		ReturnStr=AddCharToBuffer(ReturnStr,len,'\\');
		len++;
		ReturnStr=AddCharToBuffer(ReturnStr,len, 'n');
		len++;
		break;
		
		default:
		ReturnStr=AddCharToBuffer(ReturnStr,len, *ptr);
		len++;
		break;
		}
	ptr++;
}

return(ReturnStr);
}
Example #8
0
char *STREAMReadToMultiTerminator(char *Buffer, STREAM *S, char *Terms)
{
int inchar, len=0;
char *Tempptr;

Tempptr=CopyStr(Buffer,"");

inchar=STREAMReadChar(S);


//All error conditions are negative, but '0' can just mean
//no more data to read
while (inchar > -1)
{
	//if ((len % 100)== 0) Tempptr=realloc(Tempptr,(len/100 +1) *100 +2);
	//*(Tempptr+len)=inchar;

		if (inchar > 0)
		{
    	Tempptr=AddCharToBuffer(Tempptr,len,(char) inchar);
			len++;

    	if (strchr(Terms,inchar)) break;
		}
    inchar=STREAMReadChar(S);
}


*(Tempptr+len)='\0';

//if ((inchar==EOF) && (errno==ECONNREFUSED)) return(Tempptr);
if (
	((inchar==EOF) || (inchar==STREAM_DATA_ERROR))
	&& 
	(StrLen(Tempptr)==0)
   )
{
  free(Tempptr);
  return(NULL);
}

return(Tempptr);
}
Example #9
0
char *FILEReadLine(char *RetStr, FILE *f, char Term)
{
int inchar, len=0;

RetStr=CopyStr(RetStr,"");
inchar=fgetc(f);
while ((inchar != Term) && (inchar != EOF))
{
	RetStr=AddCharToBuffer(RetStr,len++,inchar & 0xFF);
	inchar=fgetc(f);
}

if ((inchar==EOF) && (StrLen(RetStr)==0))
{
	Destroy(RetStr);
	return(NULL);
}

return(RetStr);
}
Example #10
0
void ExtractVarsReadVar(const char **Fmt, const char **Msg, ListNode *Vars)
{
const char *FmtPtr, *MsgPtr;
char *VarName=NULL;
int len=0;
ListNode *Node;

FmtPtr=*Fmt;

  if (*FmtPtr=='(') FmtPtr++;
	while (*FmtPtr != ')')
	{
		VarName=AddCharToBuffer(VarName,len,*FmtPtr);
		len++;
		FmtPtr++;
	}
  if (*FmtPtr==')') FmtPtr++;

MsgPtr=*Msg;
while ((*MsgPtr !=0) && (*MsgPtr != *FmtPtr))
{
 if (*MsgPtr=='"')
 {
		do 
		{
			MsgPtr++;
		} while ((*MsgPtr != '"') && (*MsgPtr != 0));
 }
 MsgPtr++;
}

Node=ListFindNamedItem(Vars,VarName);

if (Node) Node->Item=(void *) CopyStrLen((char *) Node->Item, *Msg, MsgPtr-*Msg);
else Node=ListAddNamedItem(Vars,VarName,CopyStrLen(NULL, *Msg, MsgPtr-*Msg));

*Fmt=FmtPtr;
*Msg=MsgPtr;

DestroyString(VarName);
}
Example #11
0
char *STREAMReadToTerminator(char *Buffer, STREAM *S,unsigned char Term)
{
int inchar, len=0;
char *Tempptr;

Tempptr=CopyStr(Buffer,"");

inchar=STREAMReadChar(S);
while (inchar != EOF)
{
	//if ((len % 100)== 0) Tempptr=realloc(Tempptr,(len/100 +1) *100 +2);
	//*(Tempptr+len)=inchar;

		if (inchar >= 0)
		{
    	Tempptr=AddCharToBuffer(Tempptr,len,(char) inchar);
			len++;
		}
		else if (inchar !=STREAM_NODATA) break;
    if (inchar==Term) break;
    inchar=STREAMReadChar(S);
}


*(Tempptr+len)='\0';
//if ((inchar==EOF) && (errno==ECONNREFUSED)) return(Tempptr);
if (
	((inchar==EOF) || (inchar==STREAM_DATA_ERROR))
	&& 
	(StrLen(Tempptr)==0)
   )
{
  free(Tempptr);
  return(NULL);
}

return(Tempptr);
}
Example #12
0
char *XMLGetTag(char *Input, char **Namespace, char **TagType, char **TagData)
{
char *ptr, *tptr;
int len=0, InTag=FALSE, TagHasName=FALSE;

if (! Input) return(NULL);
if (*Input=='\0') return(NULL);
ptr=Input;

//This ensures we are never dealing with nulls
if (! *TagType) *TagType=CopyStr(*TagType,"");
if (! *TagData) *TagData=CopyStr(*TagData,"");

if (*ptr=='<') 
{
	ptr++;
	while (isspace(*ptr)) ptr++;

	len=0;
	InTag=TRUE;
	TagHasName=TRUE;

	//if we start with a slash tag, then add that to the tag name
	if (*ptr=='/') 
	{
		*TagType=AddCharToBuffer(*TagType,len,*ptr);
		len++;
		ptr++;
	}

	while (InTag)
	{
		switch (*ptr)
		{
		//These all cause us to end. NONE OF THEM REQUIRE ptr++
		//ptr++ will happen when we read tag data
		case '>':
		case '\0':
		case ' ':
		case '	':
		case '\n':
			InTag=FALSE;
		break;

		//If a namespace return value is supplied, break the name up into namespace and
		//tag. Otherwise don't
		case ':':
			if (Namespace)
			{
			tptr=*TagType;
			if (*tptr=='/')
			{
			  tptr++;
			  len=1;
			}
			else len=0;
			*Namespace=CopyStr(*Namespace,tptr);
			}
			else
			{
			*TagType=AddCharToBuffer(*TagType,len,*ptr);
			len++;
			}
			ptr++;
			
		break;

		

		case '\r':
			ptr++;
		break;

		default:
			*TagType=AddCharToBuffer(*TagType,len,*ptr);
			len++;
			ptr++;
		break;
		}
		
	}
}

//End of Parse TagName. Strip any '/'
tptr=*TagType;
if ((len > 0) && (tptr[len-1]=='/')) tptr[len-1]='\0'; 
tptr[len]='\0'; 

while (isspace(*ptr)) ptr++;


len=0;
InTag=TRUE;
while (InTag) 
{
	switch (*ptr)
	{
		//End of tag, skip '>' and fall through
		case '>':
		ptr++;

		//Start of next tag or end of text
		case '<':
		case '\0':
		 InTag=FALSE;
		break;

		//Quotes!
		case '\'':
		case '\"':

		//Somewhat ugly code. If we're dealing with an actual tag, then TagHasName
		//will be set. This means we're dealing with data within a tag and quotes mean something. 
		//Otherwise we are dealing with text outside of tags and we just add the char to
		//TagData and continue
		if (TagHasName)
		{
		tptr=ptr;
		while (*tptr != *ptr)
		{
			*TagData=AddCharToBuffer(*TagData,len,*ptr);
			len++;
			ptr++;
		}
		}
		*TagData=AddCharToBuffer(*TagData,len,*ptr);
		len++;
		ptr++;
		break;

		default:
		*TagData=AddCharToBuffer(*TagData,len,*ptr);
		len++;
		ptr++;
		break;
	}

}

//End of Parse TagData. Strip any '/'
tptr=*TagData;
if ((len > 0) && (tptr[len-1]=='/')) tptr[len-1]='\0'; 
tptr[len]='\0'; 

strlwr(*TagType);
while (isspace(*ptr)) ptr++;

return(ptr);
}
Example #13
0
char *HtmlUnQuote(char *RetStr, char *Data)
{
char *Output=NULL, *Token=NULL, *ptr;
int len=0;

Output=CopyStr(RetStr,Output);
ptr=Data;

while (ptr && (*ptr != '\0'))
{
	if (*ptr=='&')
	{
		ptr++;
		ptr=GetToken(ptr,";",&Token,0);

		if (*Token=='#')
		{
			Output=AddCharToBuffer(Output,len,strtol(Token+1,NULL,16));
			len++;
		}
		else if (strcmp(Token,"amp")==0)
		{
			Output=AddCharToBuffer(Output,len,'&');
			len++;
		}
		else if (strcmp(Token,"lt")==0)
		{
			Output=AddCharToBuffer(Output,len,'<');
			len++;
		}
		else if (strcmp(Token,"gt")==0)
		{
			Output=AddCharToBuffer(Output,len,'>');
			len++;
		}
		else if (strcmp(Token,"quot")==0)
		{
			Output=AddCharToBuffer(Output,len,'"');
			len++;
		}
		else if (strcmp(Token,"apos")==0)
		{
			Output=AddCharToBuffer(Output,len,'\'');
			len++;
		}
		else if (strcmp(Token,"tilde")==0)
		{
			Output=AddCharToBuffer(Output,len,'~');
			len++;
		}
		else if (strcmp(Token,"circ")==0)
		{
			Output=AddCharToBuffer(Output,len,'^');
			len++;
		}




	}
	else
	{
		Output=AddCharToBuffer(Output,len,*ptr);
		len++;
		ptr++;
	}
}

DestroyString(Token);

return(Output);
}
Example #14
0
char *DeQuoteStr(char *Buffer, const char *Line)
{
char *out, *in;
size_t olen=0;
char hex[3];

if (Line==NULL) return(NULL);
out=CopyStr(Buffer,"");
in=(char *) Line;

while(in && (*in != '\0') )
{
	if (*in=='\\')
	{
		in++;
		switch (*in)
		{
		  case 'e': 
			out=AddCharToBuffer(out,olen,ESC);
			olen++;
			break;


		  case 'n': 
			out=AddCharToBuffer(out,olen,'\n');
			olen++;
			break;

		  case 'r': 
			out=AddCharToBuffer(out,olen,'\r');
			olen++;
			break;

		  case 't': 
			out=AddCharToBuffer(out,olen,'\t');
			olen++;
			break;

			case 'x':
			in++; hex[0]=*in;
			in++; hex[1]=*in;
			hex[2]='\0';
			out=AddCharToBuffer(out,olen,strtol(hex,NULL,16) & 0xFF);
			olen++;
			break;

		  case '\\': 
		  default:
			out=AddCharToBuffer(out,olen,*in);
			olen++;
			break;

		}
	}
	else 
	{
		out=AddCharToBuffer(out,olen,*in);
		olen++;
	}
	in++;
}

return(out);
}