void *ListDeleteItem(ListNode *Head, void *Item) { ListNode *Node; Node=ListFindItem(Head, Item); if (Node) ListDeleteNode(Node); }
int STREAMDeleteDataProcessor(STREAM *S, char *Class, char *Name) { ListNode *Curr; char *Tempstr=NULL; int len; STREAMFlush(S); Tempstr=MCopyStr(Tempstr,Class,":",Name,NULL); Curr=ListFindNamedItem(S->ProcessingModules,Tempstr); ListDeleteNode(Curr); DestroyString(Tempstr); return(TRUE); }
void LogFileClose(const char *Path) { ListNode *Node; TLogFile *LogFile; Node=ListFindNamedItem(LogFiles,Path); if (Node) { LogFile=(TLogFile *) Node->Item; ListDeleteNode(Node); DestroyString(LogFile->Path); STREAMClose(LogFile->S); free(LogFile); } }
void ClearVars(ListNode *Vars) { ListNode *Curr; char *Str; if (! Vars) return; Curr=ListGetNext(Vars); while (Curr) { Str=ListDeleteNode(Curr); DestroyString(Str); Curr=ListGetNext(Curr); } }
void UnsetVar(ListNode *Vars,const char *Name) { ListNode *Curr; char *Str=NULL; char *Tempstr=NULL; if (Vars) return; Tempstr=CopyStr(Tempstr,Name); strlwr(Tempstr); Curr=ListFindNamedItem(Vars,Tempstr); if (Curr) { Str=ListDeleteNode(Curr); DestroyString(Str); } DestroyString(Tempstr); }
int main() { List *l = ListCreate(); int code; int index; double item; instructions(); while ((code = getchar()) != EOF) { switch (code) { case 'p': ListPrint(l); break; case 'a': //printf("add: "); if (scanf("%d %lf", &index, &item) == 2) { ListInsert(l, index, item); } else { printf("Input error\n"); } break; case 'd': if (scanf("%lf", &item) == 1) { Node *item_ptr = ListFind(l, item); if (item_ptr) { ListDeleteNode(l, item_ptr); } else { printf("Incorrect index\n"); } } else { printf("Input error\n"); } break; case 'q': ListDestroy(&l); return 0; case 'e': ListExchange(l); break; } } ListDestroy(&l); return 0; }
// deletes an item at the specified index. ( 0 based ) int ListDeleteAt( list *l, int pos ) { if ( l == NULL || pos < 0 || pos > l->itemCount ) return 0; listNode *node = l->head; for( int i = 0; i < l->itemCount; i++ ) { if ( i == pos ) { ListDeleteNode( node ); l->itemCount--; return 1; } node = node->next; } return 0; }
void ResetTTY(int tty) { struct termios *tty_data; char *Tempstr=NULL; ListNode *Curr; Tempstr=FormatStr(Tempstr,"%d",tty); Curr=ListFindNamedItem(TTYAttribs,Tempstr); if (Curr) { tty_data=(struct termios *) Curr->Item; tcsetattr(tty,TCSANOW,tty_data); ListDeleteNode(Curr); free(tty_data); } DestroyString(Tempstr); }
// deletes the specified item ( linear search ) int ListDeleteItem( list *l, void *data ) { if ( l == NULL || data == NULL ) return 0; listNode *node = l->head; for( int i = 0; i < l->itemCount; i++ ) { // compare pointers. obvs wont work for strings. if ( data == node->data ) { ListDeleteNode( node ); l->itemCount--; return 1; } node = node->next; } return 0; }
void OAuthDestroy(void *p_OAuth) { OAUTH *Ctx; ListNode *Curr; Ctx=(OAUTH *) p_OAuth; Curr=ListFindNamedItem(OAuthKeyChain, Ctx->Name); if (Curr) ListDeleteNode(Curr); DestroyString(Ctx->Name); DestroyString(Ctx->Stage1); DestroyString(Ctx->Stage2); DestroyString(Ctx->VerifyTemplate); DestroyString(Ctx->AccessToken); DestroyString(Ctx->RefreshToken); DestroyString(Ctx->RefreshURL); DestroyString(Ctx->VerifyURL); DestroyString(Ctx->VerifyCode); DestroyString(Ctx->Creds); DestroyString(Ctx->SavePath); ListDestroy(Ctx->Vars, Destroy); free(Ctx); }
main(int argc, char *argv[]) { ListNode *Curr, *Next; int OverrideType=TYPE_NONE; char *Tempstr=NULL; int result; //HTTPSetFlags(HTTP_NOCOMPRESS); StdIn=STREAMFromFD(0); STREAMSetTimeout(StdIn,0); ParseEnvironmentVariables(); DownloadQueue=ListCreate(); Tempstr=MCopyStr(Tempstr,"Movgrab ",Version,NULL); HTTPSetUserAgent(Tempstr); FormatPreference=CopyStr(FormatPreference,"mp4,flv,webm,m4v,mov,mpg,mpeg,wmv,avi,3gp,reference,mp3,m4a,wma,m3u8,m3u8-stream"); AddOutputFile("", TRUE); ParseCommandLine(argc, argv, DownloadQueue, &OverrideType); CheckSettings(); if (StrLen(Proxy)) { if (! SetGlobalConnectionChain(Proxy)) { printf("ERROR: Failed to set proxy settings to '%s'\n",Proxy); exit(1); } } if (Flags & FLAG_PRINT_USAGE) PrintUsage(); else if (Flags & FLAG_PRINT_VERSION) PrintVersion(); else if (! (Flags & FLAG_STDIN)) { if (ListSize(DownloadQueue)==0) PrintUsage(); } while (1) { if ((Flags & FLAG_STDIN) && (ListSize(DownloadQueue)==0) ) { Tempstr=STREAMReadLine(Tempstr,StdIn); StripTrailingWhitespace(Tempstr); ListAddItem(DownloadQueue,CopyStr(NULL,Tempstr)); } Curr=ListGetNext(DownloadQueue); while (Curr) { if (Flags & FLAG_TEST_SITES) { fprintf(stderr,"Checking %-20s ",Curr->Tag); fflush(NULL); } result=GrabMovie((char *) Curr->Item,OverrideType); Next=ListGetNext(Curr); //must do this after grab movie //incase more items added while grabbing if (Flags & FLAG_TEST_SITES) { if (result) fprintf(stderr," okay\n"); else fprintf(stderr," BROKEN\n"); } ListDeleteNode(Curr); Curr=Next; } if (Flags & FLAG_TEST_SITES) break; if (! (Flags & FLAG_STDIN)) break; } }
ListNode *ListFindNamedItemInsert(ListNode *Root, const char *Name) { ListNode *Prev, *Curr, *Next, *Head; int result=0, count=0; int hops=0, jumps=0, miss=0; unsigned long long val; if (! Root) return(Root); if (! StrValid(Name)) return(Root); if (Root->Flags & LIST_FLAG_MAP_HEAD) Head=MapGetChain(Root, Name); else Head=Root; //Dont use 'ListGetNext' internally Curr=Head->Next; if (! Curr) return(Head); //if LIST_FLAG_CACHE is set, then the general purpose 'Side' pointer of the head node points to a cached item if ((Root->Flags & LIST_FLAG_CACHE) && Head->Side && Head->Side->Tag) { //use next to hold Head->Side for less typing! Next=Head->Side; if (Root->Flags & LIST_FLAG_CASE) result=strcmp(Next->Tag,Name); else result=strcasecmp(Next->Tag,Name); if (result==0) return(Next); //if result < 0 AND ITS AN ORDERED LIST then it means the cached item is ahead of our insert point, so we might as well jump to it else if ((Root->Flags & LIST_FLAG_ORDERED) && (result < 0)) Curr=Next; } //Check last item in list Prev=Head->Prev; if (Prev && (Prev != Head) && Prev->Tag) { if (Head->Flags & LIST_FLAG_CASE) result=strcmp(Prev->Tag,Name); else result=strcasecmp(Prev->Tag,Name); if (result == 0) return(Prev); if ((Head->Flags & LIST_FLAG_ORDERED) && (result < 1)) return(Prev); } Prev=Head; while (Curr) { Next=Curr->Next; if (Curr->Tag) { if (Root->Flags & LIST_FLAG_CASE) result=strcmp(Curr->Tag,Name); else result=strcasecmp(Curr->Tag,Name); if (result==0) { if (Root->Flags & LIST_FLAG_SELFORG) ListSwapItems(Curr->Prev, Curr); return(Curr); } if ((result > 0) && (Root->Flags & LIST_FLAG_ORDERED)) return(Prev); //Can only get here if it's not a match if (Root->Flags & LIST_FLAG_TIMEOUT) { val=ListNodeGetTime(Curr); if ((val > 0) && (val < GetTime(TIME_CACHED))) { Destroy(Curr->Item); ListDeleteNode(Curr); } } } hops++; count++; Prev=Curr; Curr=Next; } return(Prev); }
void ConnectManagerMainLoop() { TConnectManagerItem *Item, *NewItem; ListNode *Curr, *Prev; int highfd=0; fd_set ReadSet, WriteSet; int sock, result, SelectResult, NextTimerFire; STREAM *S; time_t Now; struct timeval tv; int MoreData=FALSE; while (1) { MoreData=FALSE; time(&Now); NextTimerFire=60; Curr=ListGetNext(Timers); while (Curr) { Item=(TConnectManagerItem *) Curr->Item; if (Item->LastTimerFire==0) Item->LastTimerFire=Now; result=(Item->LastTimerFire + Item->TimerVal) - Now; if (result < NextTimerFire) NextTimerFire=result; Curr=ListGetNext(Curr); } FD_ZERO(&ReadSet); FD_ZERO(&WriteSet); Curr=ListGetNext(ConnectManServers); while (Curr) { Item=(TConnectManagerItem *) Curr->Item; S=(STREAM *) Item->Data; FD_SET(S->in_fd,&ReadSet); if (S->in_fd > highfd) highfd=S->in_fd; Curr=ListGetNext(Curr); } Curr=ListGetNext(ConnectManClients); while (Curr) { Item=(TConnectManagerItem *) Curr->Item; S=(STREAM *) Item->Data; if (! S) { ListDeleteNode(Curr); continue; } if (S->State & SS_CONNECTING) { FD_SET(S->in_fd,&WriteSet); } if (S->InEnd > S->InStart) MoreData=TRUE; else { //always add to read set FD_SET(S->in_fd,&ReadSet); if (S->in_fd > highfd) highfd=S->in_fd; } Curr=ListGetNext(Curr); } if (MoreData) { tv.tv_usec = 10; tv.tv_sec = 0; SelectResult=0; } else { //SELECT!!! tv.tv_usec = 20000; tv.tv_sec = NextTimerFire; } SelectResult=select(highfd+1,&ReadSet,&WriteSet,NULL,&tv); if (SelectResult > 0) { Curr=ListGetNext(ConnectManServers); while (Curr) { Item=(TConnectManagerItem *) Curr->Item; S=(STREAM *) Item->Data; if (! S) { ListDeleteNode(Curr); continue; } if (FD_ISSET(S->in_fd,&ReadSet)) { sock=TCPServerSockAccept(S->in_fd,&S->Path); if (sock > -1) { S=STREAMFromFD(sock); STREAMSetFlushType(S,FLUSH_LINE,0,0); NewItem=ConnectManagerAddIncoming(S,Item->Name, Item->OnData); if (Item->OnConnect) Item->OnConnect(NewItem); } } Curr=ListGetNext(Curr); } } Curr=ListGetNext(ConnectManClients); while (Curr) { Item=(TConnectManagerItem *) Curr->Item; S=(STREAM *) Item->Data; if (! S) { ListDeleteNode(Curr); continue; } if ((SelectResult > 0) && FD_ISSET(S->in_fd,&WriteSet)) { if (S->State & SS_CONNECTING) { if (STREAMIsConnected(S)) { STREAMSetFlags(S, 0, SF_NONBLOCK); if (Item->OnConnect) Item->OnConnect(Item); } } } if ( (S->InEnd > S->InStart) || ((SelectResult > 0) && (FD_ISSET(S->in_fd,&ReadSet))) ) { if (! (S->State & SS_CONNECTING)) { if (Item->OnData) { result=Item->OnData(S, Item->Name); if (! result) { STREAMClose(S); Prev=ListGetPrev(Curr); ListDeleteNode(Curr); free(Item); Curr=Prev; } else if (result==RECONNECT) { STREAMClose(S); S=STREAMCreate(); STREAMConnectToHost(S,Item->Host,Item->Port,CONNECT_NONBLOCK); Item->Data=(void *) S; } } } } Curr=ListGetNext(Curr); } time(&Now); Curr=ListGetNext(Timers); while (Curr) { Item=(TConnectManagerItem *) Curr->Item; if ( (Now - Item->LastTimerFire) >= Item->TimerVal ) { if (Item->OnData) ((ONTIMER_FUNC)Item->OnData)(Item->Data,Item->Name); Item->LastTimerFire=Now; } Curr=ListGetNext(Curr); } } }