static void CGIDisplayOptions(const char *HashType, const char *Encoding, const char *LineEnding, int OutputLength)
{
char *Token=NULL, *Tempstr=NULL;
const char *ptr;
ListNode *Items=NULL;
int i;
Items=ListCreate();
printf("<tr>\r\n");
Tempstr=HashAvailableTypes(Tempstr);
ptr=GetToken(Tempstr, ",",&Token,0);
while (ptr)
{
ListAddNamedItem(Items, Token, CopyStr(NULL, Token));
ptr=GetToken(ptr, ",",&Token,0);
}
printf("<td align=left>Type: ");
CGIPrintSelect("HashType", HashType, Items);
ListClear(Items, Destroy);
printf("</td>\r\n");
printf("<td align=right>Encoding: ");
for (i=0; EncodingNames[i] !=NULL; i++) SetVar(Items, EncodingNames[i], EncodingDescriptions[i]);
CGIPrintSelect("Encoding", Encoding, Items);
ListClear(Items, Destroy);
printf("</td>\r\n");
printf("<tr>\r\n");
printf("<td align=left>Line Ending: </td>");
printf("<td align=right>");
for (i=0; LineEndingNames[i] !=NULL; i++) SetVar(Items, LineEndingNames[i], LineEndingDescriptions[i]);
CGIPrintSelect("LineEnding", LineEnding, Items);
ListClear(Items, Destroy);
printf("</td>\r\n");
printf("</tr>\r\n");
printf("<tr>\r\n");
printf("<td align=left>Hash Length: </td>");
printf("<td align=right>");
if (OutputLength > 0) printf("<input type=text width=90%% name=\"OutputLength\" style=\"font-weight: bold; font-size:16px\" value=\"%d\">\r\n",OutputLength);
else printf("<input type=text width=90%% name=\"OutputLength\" style=\"font-weight: bold; font-size:16px\">\r\n");
printf("</td>\r\n");
printf("</tr>\r\n");
ListDestroy(Items, Destroy);
Destroy(Tempstr);
Destroy(Token);
}
/// HIFN Disconnects a Source VChan from all its Sink VChans
static BOOL disconnectSourceVChan (SourceVChan_type* srcVChan)
{
if (!srcVChan) return FALSE;
SinkVChan_type* sinkVChan = NULL;
for (size_t i = 1; i <= ListNumItems(srcVChan->sinkVChans); i++) {
sinkVChan = *(SinkVChan_type**)ListGetPtrToItem(srcVChan->sinkVChans, i);
sinkVChan->sourceVChan = NULL;
// if Sink VChan is open, close it
if (sinkVChan->baseClass.isOpen) {
sinkVChan->baseClass.isOpen = VChan_Closed;
if (sinkVChan->baseClass.VChanStateChangeCBFptr)
(*sinkVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)sinkVChan, sinkVChan->baseClass.VChanOwner, sinkVChan->baseClass.isOpen);
}
}
ListClear(srcVChan->sinkVChans);
// if Source VChan is open, close it
if (srcVChan->baseClass.isOpen) {
srcVChan->baseClass.isOpen = VChan_Closed;
if (srcVChan->baseClass.VChanStateChangeCBFptr)
(*srcVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)srcVChan, srcVChan->baseClass.VChanOwner, srcVChan->baseClass.isOpen);
}
return TRUE;
}
void HTTPReadHeaders(STREAM *S, HTTPInfoStruct *Header)
{
char *Tempstr=NULL;
ListClear(Header->ServerHeaders,DestroyString);
Header->ContentLength=0;
Header->RedirectPath=CopyStr(Header->RedirectPath,"");
Header->Flags &= ~(HTTP_CHUNKED | HTTP_GZIP | HTTP_DEFLATE);
Tempstr=STREAMReadLine(Tempstr,S);
if (Tempstr)
{
HTTPParseResponseLine(S, Header,Tempstr);
Tempstr=STREAMReadLine(Tempstr,S);
}
while (Tempstr)
{
StripTrailingWhitespace(Tempstr);
if (StrLen(Tempstr)==0) break;
HTTPParseHeader(S, Header,Tempstr);
Tempstr=STREAMReadLine(Tempstr,S);
}
S->BytesRead=0;
DestroyString(Tempstr);
}
void ListDestroy(ListNode *ListStart, LIST_ITEM_DESTROY_FUNC ItemDestroyer)
{
if (! ListStart) return;
ListClear(ListStart, ItemDestroyer);
free(ListStart->Item);
free(ListStart);
}
Tree* ParseFull(char* c, Err* E){
Tree* T;
List* L=ParseBuildList(c,E);
(E->pres)=0;
if ((E->pres)==1) {
ListClear(L);
return NULL;
}
T=ParseBuildTree(L,E);
ListClear(L);
if ((E->pres)==1) {
TreeFree(T);
return NULL;
}
return T;
}
void HTTPReadHeaders(STREAM *S, HTTPInfoStruct *Info)
{
char *Tempstr=NULL, *ptr;
ListClear(Info->ServerHeaders,DestroyString);
Info->ContentLength=0;
//Not needed
//Info->RedirectPath=CopyStr(Info->RedirectPath,"");
Info->Flags &= ~(HTTP_CHUNKED | HTTP_GZIP | HTTP_DEFLATE);
Tempstr=STREAMReadLine(Tempstr,S);
if (Tempstr)
{
if (Info->Flags & HTTP_DEBUG) fprintf(stderr,"RESPONSE: %s\n",Tempstr);
if (strncmp(Tempstr,"HTTP/",5)==0)
{
ptr=strchr(Tempstr,' ');
ptr++;
Info->ResponseCode=CopyStrLen(Info->ResponseCode,ptr,3);
STREAMSetValue(S,"HTTP:ResponseCode",Info->ResponseCode);
}
Tempstr=STREAMReadLine(Tempstr,S);
}
while (Tempstr)
{
StripTrailingWhitespace(Tempstr);
if (StrLen(Tempstr)==0) break;
HTTPParseHeader(S, Info,Tempstr);
Tempstr=STREAMReadLine(Tempstr,S);
}
//Handle Response Codes
if (StrLen(Info->ResponseCode))
{
if (*Info->ResponseCode=='3')
{
//No longer a flag, HTTP Redirect is now just a response code
//Info->Flags |= HTTP_REDIRECT;
}
if (strcmp(Info->ResponseCode,"401")==0)
{
if (Info->Authorization) Info->Authorization->Flags |= HTTP_AUTH_BASIC;
}
if (strcmp(Info->ResponseCode,"407")==0)
{
if (Info->ProxyAuthorization) Info->ProxyAuthorization->Flags |= HTTP_PROXY_AUTH;
}
}
S->BytesRead=0;
DestroyString(Tempstr);
}
void MapClear(ListNode *Map, LIST_ITEM_DESTROY_FUNC ItemDestroyer)
{
ListNode *Node;
if (Map->Flags & LIST_FLAG_MAP_HEAD)
{
for (Node=(ListNode *) Map->Item; Node->Flags & LIST_FLAG_MAP_CHAIN; Node++) ListClear(Node, ItemDestroyer);
}
}
main(int argc, char *argv[])
{
STREAM *S, *Out;
ListNode *Vars;
char *Path=NULL, *Tempstr=NULL, *ptr;
int bytes_read, bytes_total, val, result;
S=STREAMOpenFile(argv[1],O_RDONLY);
Out=STREAMFromFD(1);
Vars=ListCreate();
while (TarReadHeader(S, Vars))
{
Path=CopyStr(Path,GetVar(Vars,"Path"));
printf("PATH: %s %s %s\n",Path,GetVar(Vars,"Size"),GetVar(Vars,"Type"));
if (StrLen(Path))
{
ptr=GetVar(Vars,"Type");
if (ptr && (strcmp(ptr,"file")==0))
{
bytes_read=0;
bytes_total=atoi(GetVar(Vars,"Size"));
Tempstr=SetStrLen(Tempstr,BUFSIZ);
while (bytes_read < bytes_total)
{
val=bytes_total - bytes_read;
if (val > BUFSIZ) val=BUFSIZ;
if ((val % 512)==0) result=val;
else result=((val / 512) + 1) * 512;
result=STREAMReadBytes(S,Tempstr,result);
if (result > val) result=val;
printf("READ: %d\n",val);
fflush(NULL);
if (Out) STREAMWriteBytes(Out,Tempstr,result);
bytes_read+=result;
}
}
}
ListClear(Vars,DestroyString);
}
ListDestroy(Vars,DestroyString);
DestroyString(Tempstr);
DestroyString(Path);
}
void HTTPSessionClear(void *p_Trans)
{
HTTPSession *Trans;
if (! p_Trans) return;
Trans=(HTTPSession *) p_Trans;
//Clear everything but SESSION_REUSE, SESSION_AUTHENTICATED and HTTP_SSL, which are persistent
Trans->Flags &= (SESSION_REUSE | SESSION_AUTHENTICATED | SESSION_UPLOAD | HTTP_SSL);
Trans->Method=CopyStr(Trans->Method,"");
Trans->ResponseCode=CopyStr(Trans->ResponseCode,"");
Trans->URL=CopyStr(Trans->URL,"");
Trans->Path=CopyStr(Trans->Path,"");
Trans->Arguments=CopyStr(Trans->Arguments,"");
Trans->Destination=CopyStr(Trans->Destination,"");
Trans->ContentType=CopyStr(Trans->ContentType,"");
Trans->ContentBoundary=CopyStr(Trans->ContentBoundary,"");
Trans->UserName=CopyStr(Trans->UserName,"");
Trans->Password=CopyStr(Trans->Password,"");
Trans->AuthType=CopyStr(Trans->AuthType,"");
Trans->Host=CopyStr(Trans->Host,"");
Trans->ClientReferrer=CopyStr(Trans->ClientReferrer,"");
Trans->UserAgent=CopyStr(Trans->UserAgent,"");
Trans->SearchPath=CopyStr(Trans->SearchPath,"");
//Do not clear these values, as 'SessionClear' is only called on persistent
//'HTTP Keep-Alive' sessions
//Trans->Protocol=CopyStr(Trans->Protocol,"");
//Trans->Cipher=CopyStr(Trans->Cipher,"");
//Trans->ClientIP=CopyStr(Trans->ClientIP,"");
//Trans->ClientHost=CopyStr(Trans->ClientHost,"");
//Trans->StartDir=CopyStr(Trans->StartDir,"");
//Trans->HomeDir=CopyStr(Trans->HomeDir,"");
//Trans->RealUser=CopyStr(Trans->RealUser,"");
//Trans->UserSettings=CopyStr(Trans->UserSettings,"");
//Trans->ServerName=CopyStr(Trans->ServerName,"");
ListClear(Trans->Headers,DestroyString);
}
/*
* SEARCH
* FUZZING
* - small
* - lager
* - equal
* - notequal
* WRITE
* PROCESS(Process List)
* THREADLIST
* ATTACH
* CONTROL
* - STOP
* - START
* SHOWLIST(Data List)
* CLEAR
* EXIT
*/
int main(int argc, const char* argv[]) {
getUUID();
char message[BUFSIZE];
char command1[BUFSIZE] = { '\0', }, command2[BUFSIZE] = { '\0', },command3[BUFSIZE] = { '\0', };
while (1) {
printf("Lazenca$ ");
fgets(message, BUFSIZE, stdin);
fflush (stdin);
//입력값이 있는지 없는지 확인
if (strlen(message) > 1) {
sscanf(message, "%s%s%s", command1, command2, command3);
/*printf("command1 : %s, command2 : %s, command3 : %s\n",
strupr(command1), command2, command3);*/
//Process Attach
if (!strcmp(ATTACH, strupr(command1))) {
ListClear();
ProcAttach(command2);
continue;
//Process List
} else if (!strcmp(PROCESSLIST, strupr(command1))) {
showProcessList();
continue;
//Process Exit
} else if (!strcmp(EXIT, strupr(command1))) {
exit(0);
}
char tempPath[256];
sprintf(tempPath, "/proc/%d", privatePid);
if (checkDir(tempPath)) {
//검색
if (!strcmp(SEARCH, strupr(command1))) {
MemorySearch(command2);
//퍼징
} else if (!strcmp(FUZZING, strupr(command1))) {
MemoryFuzzing(command2);
//값 변경
} else if (!strcmp(WRITE, strupr(command1))) {
MemoryWrite(command2, command3);
//Thread List
} else if (!strcmp(THREADLIST, strupr(command1))) {
showThreadList();
//Process Control
} else if (!strcmp(CONTROL, strupr(command1))) {
ThreadControl(command2, command3);
//Data List
} else if (!strcmp(DATALIST, strupr(command1))) {
ShowDataList();
//Data List Clear
} else if (!strcmp(CLEAR, strupr(command1))) {
ListClear();
//Data Lock
} else if (!strcmp(DATALOCK, strupr(command1))) {
DataLock(command2);
} else if (!strcmp(LOCKLIST, strupr(command1))) {
ShowLockDataList();
} else {
printf("Main Command Input Error!\n");
}
} else {
ListClear();
printf("%s\n", errorMsgPid);
}
}
}
return 0;
}
void *AlertSyslogParseArgs(char *Args)
{
int idx;
char *ptr;
ActionSyslogRec *data;
QueueList *ll, *list;
QueueList *opt, *options;
opt = options = ll = list = NULL;
ptr = NULL;
DEBUGPATH;
DBG((printf("%s(%s)\n", __FUNCTION__, Args)));
data = (ActionSyslogRec *) calloc(sizeof(ActionSyslogRec), 1);
data->options = 0;
data->facility = LOG_AUTH;
data->priority = LOG_INFO;
list = ListAdd(Args, list, ',');
for (ll = list; ll != NULL; ll = ll->next) {
if ((ptr = ParseCmp("facility", ll->item)) != NULL) {
for (idx = 0; idx < ARRAYSIZE(hlbr_syslog_facilitys); idx++) {
if (strcasecmp(hlbr_syslog_facilitys[idx].name, ptr) == 0) {
DBG((printf
("facility(%s) = %d\n", ptr,
hlbr_syslog_facilitys[idx].val)));
data->facility = hlbr_syslog_facilitys[idx].val;
}
}
FREE(ptr);
}
if ((ptr = ParseCmp("priority", ll->item)) != NULL) {
for (idx = 0; idx < ARRAYSIZE(hlbr_syslog_prioritys); idx++) {
if (strcasecmp(hlbr_syslog_prioritys[idx].name, ptr) == 0) {
DBG((printf
("priority(%s) = %d\n", ptr,
hlbr_syslog_prioritys[idx].val)));
data->priority = hlbr_syslog_prioritys[idx].val;
}
}
FREE(ptr);
}
if ((ptr = ParseCmp("options", ll->item)) != NULL) {
options = ListAdd(ptr, options, '|');
for (opt = options; opt != NULL; opt = opt->next) {
for (idx = 0; idx < ARRAYSIZE(hlbr_syslog_options); idx++) {
if (strcasecmp(hlbr_syslog_options[idx].name, opt->item)
== 0) {
DBG((printf
("priority(%s) = %d\n", opt->item,
hlbr_syslog_options[idx].val)));
data->options |= hlbr_syslog_options[idx].val;
}
}
}
ListClear(options);
FREE(ptr);
}
}
ListClear(list);
return data;
}
