/* * render() processes a html page and returns a buffer containing the * rendered page */ Page * render(FILE *input, int screenwidth) { Page *bfr; if ((bfr = malloc(sizeof *bfr)) == 0) return 0; bfr->pagealloc= 10240; /* alloc 10k for the page */ bfr->page = malloc(bfr->pagealloc); bfr->pagelen = 0; /* nothing written yet */ bfr->xp = 0; /* set up xp and start of */ bfr->startx = 0; /* line */ bfr->hrefs = malloc(1); /* prepare the href array */ bfr->nrhrefs = 0; bfr->title = 0; /* ... the title */ bfr->titlelen = 0; bfr->isbol = 1; /* and mark beginning of line */ memset(&state, 0, sizeof state); /* reset state block */ state.align = wwLEFT; state.width = screenwidth; state.doing = D_VANILLA; state.page = bfr; addchar(DLE); addchar(' '); parse_it(input, 0, 0, ALL_TAGS); addchar(0); /* null-terminate the page */ bfr->pagelen--; return bfr; } /* render */
/* -------------------------------------------------------------------- */ static BOOL alias_route(char *str, const char *srch) { FILE *fBuf; char line[90]; char *words[256]; char path[80]; sprintf(path, "%s\\route.cit", cfg.homepath); if ((fBuf = fopen(path, "r")) == NULL) /* ASCII mode */ { crashout("Can't find route.cit!"); } while (fgets(line, 90, fBuf) != NULL) { if (line[0] != '#') continue; if (strnicmp(line, srch, 5) != SAMESTRING) continue; parse_it( words, line); if (strcmpi(srch, words[0]) == SAMESTRING) { if (strcmpi(str, words[1]) == SAMESTRING) { fclose(fBuf); strcpy(str, words[2]); return TRUE; } } } fclose(fBuf); return FALSE; }
/* ------------------------------------------------------------------------ */ static int directory_l(char *str) { FILE *fBuf; char line[90]; char *words[256]; char path[80]; sprintf(path, "%s\\external.cit", cfg.homepath); if ((fBuf = fopen(path, "r")) == NULL) /* ASCII mode */ { crashout("Can't find route.cit!"); } while (fgets(line, 90, fBuf) != NULL) { if (line[0] != '#') continue; if (strnicmp(line, "#DIRE", 5) != SAMESTRING) continue; parse_it( words, line); if (strcmpi(words[0], "#DIRECTORY") == SAMESTRING) { if (u_match(str, words[1])) { fclose(fBuf); return TRUE; } } } fclose(fBuf); return FALSE; }
int add_to_mater(char *info, t_v3D **coord, t_materiau *mater) { int *col; if (!info) return (write(2, MALLOC_ERR, 21)); if (!(col = parse_it(info, 3))) return (write(2, MALLOC_ERR, 21)); if (fill_color(mater, col, 0)) return (1); free(info); return (0); }
int get_coord(char *info, t_v3D **coord, t_materiau *mater) { int *coor; if (!info) return (write(2, MALLOC_ERR, 21)); if (!(coor = parse_it(info, 3))) return (write(2, MALLOC_ERR, 21)); if (!(*coord = fill_coord(coor))) return (write(2, MALLOC_ERR, 21)); free(info); return (0); }
int parse(char* s, inode* dest){ int length = strlen(s); free (dest); if (length <=0) return -1; else if ( length ==1) if(s[0]=='/'){ dest = (inode*)&(super.root); return 0;} else return -1; else { return parse_it( s + 1 , dest,super.root);}}
Bool TERMWINDOWMEMBER get_next_room(char *here, char *there) { assert(nodefile); char line[95]; while (fgets(line, 90, nodefile) != NULL) { if (line[0] != '#') { continue; } char *words[256]; const int count = parse_it(words, line); if (SameString(words[0], getnetmsg(37))) { fclose(nodefile); nodefile = NULL; return (FALSE); } if (SameString(words[0], getnetmsg(38))) { CopyString2Buffer(here, words[1], LABELSIZE); if (count > 2) { CopyString2Buffer(there, words[2], LABELSIZE); } else { strcpy(there, here); } return (TRUE); } } fclose(nodefile); nodefile = NULL; return (FALSE); }
int get_mat(char *info, t_v3D **coord, t_materiau *mater) { int j; int *mat; j = -1; if (!info) return (write(2, MALLOC_ERR, 21)); while (++j < 1) if (!my_strcmp(info, g_defmat[j].name)) { mater = &(g_defmat[j].materiau); return (0); } if (!(mat = parse_it(info, 5))) return (write(2, MALLOC_ERR, 21)); if (!(mater = fill_mat(mat))) return (write(2, MALLOC_ERR, 21)); free(info); return (0); }
void saveNewReality (struct messNode *nodeArray, char *room, int iTopNode) { int hInFile, hOutFile, i ; char buf[256], originalBuf[256], *words[16], *curnode = NULL ; BOOL shouldBePresent, present ; sprintf (buf, "%s\\NODES.CIT", cfg.homepath) ; hInFile = sopen (buf, O_TEXT | O_RDONLY, SH_DENYNO) ; sprintf (buf, "%s\\NODES.!!!", cfg.homepath) ; unlink (buf) ; hOutFile = sopen (buf, O_CREAT | O_TEXT | O_WRONLY, SH_DENYNO, S_IREAD | S_IWRITE) ; if (-1 == hInFile) crashout ("Problem opening NODES.CIT. Snorp.") ; if (-1 == hOutFile) crashout ("Problem opening NODES.!!!. Foom.") ; /* When we identify a #NODE, a BOOL tells us whether that #NODE shares */ /* room. If not, and the room is found, it's not passed through to */ /* the temporary file. If so, and the roomname ISN'T found before the */ /* next #NODE, it is ADDED just before the next #NODE (or EOF). */ originalBuf[0] = '\0' ; while ( !eof(hInFile) ) { /* In every loop, the first thing we do is write the line from the */ /* PREVIOUS loop around. */ write (hOutFile, originalBuf, strlen (originalBuf)) ; if (!sfgets (buf, 255, hInFile)) break ; /* Error reading file. */ strcpy (originalBuf, buf) ; if ('#' != buf[0]) /* It's not a keyword. */ continue ; parse_it (words, buf) ; /* We are only concerned about #NODE and #ROOM. If we're reading */ /* #NODE line, first check whether a #ROOM line needs to be added */ /* for the previous node. */ if (SAMESTRING == stricmp (words[0], "#NODE")) { addRoomIfShould (curnode, shouldBePresent, present, room, hOutFile) ; /* In any event, find the node's memory bro and fill in BOOLs. */ for (i = 0; i <= iTopNode; i++) if (SAMESTRING == stricmp (nodeArray[i].nodeName, words[1])) break ; if (i > iTopNode) /* Couldn't find node in memory. */ { curnode = NULL ; continue ; } present = FALSE ; shouldBePresent = nodeArray[i].fShared ; curnode = nodeArray[i].nodeName ; } /* If present is TRUE, we don't need to worry about parsing the */ /* rest of the #ROOMs, but instead will sit around until another */ /* #NODE comes along. But if present is false, is this line the */ /* room we're looking for? And should we remove it? */ if (present) continue ; if (SAMESTRING == stricmp (words[0], "#ROOM")) if (SAMESTRING == stricmp (words[1], room)) { present = TRUE ; /* If we've found it and wished we hadn't, nuke the buffer */ /* and end, so nothing gets written. */ if (!shouldBePresent) originalBuf[0] = '\0' ; } } /* Now that we're out of the file, we need to call addRoomIfShould */ /* once more to add a #ROOM line to the last node in the nodes file, */ /* if necessary. And finally, write the last line of the file */ addRoomIfShould (curnode, shouldBePresent, present, room, hOutFile) ; write (hOutFile, originalBuf, strlen (originalBuf)) ; close (hInFile) ; if (0 == close (hOutFile)) /* SUccessful close. Rename... */ { sprintf (buf, "%s\\NODES.CIT", cfg.homepath) ; sprintf (originalBuf, "%s\\NODES.!!!", cfg.homepath) ; unlink (buf) ; rename (originalBuf, buf) ; } else cPrintf ("Unable to close NODES.!!! Spork.") ; }
Bool ReadNodesCit(NodesCitC **newNode, const char *NameOrAddrToFind, ModemConsoleE W, Bool option) #endif { FILE *fBuf; char *words[256]; int i; char path[80]; int count; uint lineno = 0; l_slot logslot; if (!read_node_ddata()) { TWwPrintf(W, getmsg(59)); return (FALSE); } const char **nodekeywords = (const char **) nddd->aux; const char **nettypes = (const char **) nddd->next->aux; const char **nodemsgs = (const char **) nddd->next->next->aux; label NameToFind; CopyStringToBuffer(NameToFind, NameOrAddrToFind); if (SameString(NameOrAddrToFind, getnodemsg(2))) { // if default, start fresh if (!clearNode(newNode)) { dump_node_ddata(); return (FALSE); } } else { // else first read in default #ifdef WINCIT ReadNodesCit(TW, newNode, getnodemsg(2), W, FALSE); #else ReadNodesCit(newNode, getnodemsg(2), W, FALSE); #endif if (*newNode) { #ifdef WINCIT logslot = nodexists(NameOrAddrToFind, TW ? TW->LogOrder : NULL); #else logslot = nodexists(NameOrAddrToFind); #endif if (logslot == CERROR) { TWwDoCR(W); TWwPrintf(W, getnodemsg(3), NameOrAddrToFind); if (strlen(NameOrAddrToFind) < 4) { char temp[4]; CopyStringToBuffer(temp, NameOrAddrToFind); strlwr(temp); TWwPrintf(W, getnodemsg(4), temp, cfg.locID); } dump_node_ddata(); return (FALSE); } label Alias, LocID; #ifdef WINCIT if (!*LogTab[TW ? TW->LogOrder[logslot] : logslot].GetAlias(Alias, sizeof(Alias)) || !*LogTab[TW ? TW->LogOrder[logslot] : logslot].GetLocID(LocID, sizeof(LocID))) #else if (!*LTab(logslot).GetAlias(Alias, sizeof(Alias)) || !*LTab(logslot).GetLocID(LocID, sizeof(LocID))) #endif { TWwDoCR(W); TWwPrintf(W, getnodemsg(5), NameOrAddrToFind); dump_node_ddata(); return (FALSE); } (*newNode)->SetAlias(Alias); (*newNode)->SetLocID(LocID); label FileName; sprintf(FileName, getnodemsg(6), (*newNode)->GetAlias()); (*newNode)->SetMailFileName(FileName); // Make sure NameToFind is a name, not address. #ifdef WINCIT LogTab[TW ? TW->LogOrder[logslot] : logslot].GetName(NameToFind, sizeof(NameToFind)); #else LTab(logslot).GetName(NameToFind, sizeof(NameToFind)); #endif // Support for optional nodes.cit entries. (*newNode)->SetName(NameToFind); } } if (!*newNode) { cOutOfMemory(44); dump_node_ddata(); return (FALSE); } compactMemory(); sprintf(path, sbs, cfg.homepath, getnodemsg(8)); if ((fBuf = fopen(path, FO_R)) == NULL) // ASCII mode { TWdoccr(); TWcPrintf(getmsg(15), getnodemsg(8)); TWdoccr(); dump_node_ddata(); return (option); } char line[256]; Bool FoundOurEntry = FALSE; long pos = ftell(fBuf); while (fgets(line, 254, fBuf) != NULL) { lineno++; if (line[0] != '#') { pos = ftell(fBuf); continue; } // Don't read anything until we found our entry, except possible beginnings of our entry. (#NODE...) if (!FoundOurEntry && strnicmp(line + 1, nodekeywords[NOK_NODE], strlen(nodekeywords[NOK_NODE])) != SAMESTRING) { pos = ftell(fBuf); continue; } // Save a copy of the line in case this is the #LOGIN macro: parse_it // changes what is passed to it. char ltmp[256]; CopyStringToBuffer(ltmp, line); count = parse_it(words, line); // Look up our first word in table of keywords. for (i = 0; i < NOK_NUM; i++) { if (SameString(words[0] + 1, nodekeywords[i])) { //^ add one for '#' break; } } if (i < NOK_NUM && !words[1][0]) // valid keywords need a param { TWcPrintf(getnodemsg(9), getnodemsg(8), ltoac(lineno), nodekeywords[i], ns); TWdoccr(); continue; } if (i == NOK_NODE) { // This is a #NODE line... if we have alread found our entry, // then this is the start of the next one, and we are done. if (FoundOurEntry) { fclose(fBuf); dump_node_ddata(); return (TRUE); } // This is a #NODE line... if it is for us, then we have now // found our entry. If not, then we continue looking. if (SameString(NameToFind, words[1])) { FoundOurEntry = TRUE; } else { pos = ftell(fBuf); continue; } } switch (i) { case NOK_BAUD: { PortSpeedE PS = digitbaud(atol(words[1])); if (PS == PS_ERROR) { TWcPrintf(getnodemsg(9), getnodemsg(8), ltoac(lineno), nodekeywords[i], words[1]); TWdoccr(); } else { (*newNode)->SetBaud(PS); } break; } case NOK_DIALOUT: case NOK_PHONE: { (*newNode)->SetDialOut(words[1]); if (strlen(words[1]) > 49) { TWcPrintf(getnodemsg(1), getnodemsg(8), ltoac(lineno), nodekeywords[i], 50); TWdoccr(); } break; } case NOK_PREDIAL: { (*newNode)->SetPreDial(words[1]); if (strlen(words[1]) > 63) { TWcPrintf(getnodemsg(1), getnodemsg(8), ltoac(lineno), nodekeywords[i], 64); TWdoccr(); } break; } case NOK_FETCH_TIMEOUT: { (*newNode)->SetFetchTimeout(atoi(words[1])); break; } case NOK_ZIP: { if (!words[2][0]) // need second param { TWcPrintf(getnodemsg(9), getnodemsg(8), ltoac(lineno), nodekeywords[i], ns); TWdoccr(); continue; } else { (*newNode)->SetCreatePacket(words[1]); if (strlen(words[1]) > 39) { TWcPrintf(getnodemsg(1), getnodemsg(8), ltoac(lineno), nodekeywords[i], 40); TWdoccr(); } (*newNode)->SetExtractPacket(words[2]); if (strlen(words[2]) > 39) { TWcPrintf(getnodemsg(1), getnodemsg(8), ltoac(lineno), nodekeywords[i], 40); TWdoccr(); } } break; } case NOK_NETWORK: { (*newNode)->SetNetworkRevisionNumber(0); NETTYPES j; for (j = (NETTYPES) 0; j < NET_NUM; j = (NETTYPES) (j + 1)) { if (SameString(words[1], nettypes[j])) { break; } } if (j == NET_DCIT11) { j = NET_DCIT10; } if (j == NET_6_9a) { (*newNode)->SetNetworkRevisionNumber(1); j = NET_6_9; } if (j == NET_NUM) { TWcPrintf(getnodemsg(9), getnodemsg(8), ltoac(lineno), nodekeywords[i], words[1]); TWdoccr(); } else { (*newNode)->SetNetworkType(j); } break; } case NOK_PROTOCOL: { (*newNode)->SetProtocol(words[1][0]); break; } case NOK_AUTOHALL: { (*newNode)->SetAutoHall(hallexists(words[1])); if (strlen(words[1]) > LABELSIZE) { TWcPrintf(getnodemsg(1), getnodemsg(8), ltoac(lineno), nodekeywords[i], LABELSIZE + 1); TWdoccr(); } break; } case NOK_AUTOGROUP: { (*newNode)->SetAutoGroup(FindGroupByName(words[1])); if (strlen(words[1]) > LABELSIZE) { TWcPrintf(getnodemsg(1), getnodemsg(8), ltoac(lineno), nodekeywords[i], LABELSIZE + 1); TWdoccr(); } break; } case NOK_MAPUNKGROUP: { g_slot GroupSlot = FindGroupByName(words[1]); if (GroupSlot == CERROR) { GroupSlot = SPECIALSECURITY; } (*newNode)->SetMapUnknownGroup(GroupSlot); if (strlen(words[1]) > LABELSIZE) { TWcPrintf(getnodemsg(1), getnodemsg(8), ltoac(lineno), nodekeywords[i], LABELSIZE + 1); TWdoccr(); } break; } case NOK_LOGIN: { (*newNode)->SetLoginMacro(ltmp + strlen(nodekeywords[NOK_LOGIN]) + 1); break; } case NOK_NODE: { // A bit silly. (*newNode)->SetName(words[1]); if (strlen(words[1]) > LABELSIZE) { TWcPrintf(getnodemsg(1), getnodemsg(8), ltoac(lineno), nodekeywords[i], LABELSIZE + 1); TWdoccr(); } if (count > 2) { (*newNode)->SetOldRegion(words[2]); if (strlen(words[2]) > LABELSIZE) { TWcPrintf(getnodemsg(1), getnodemsg(8), ltoac(lineno), nodekeywords[i], LABELSIZE + 1); TWdoccr(); } } else { (*newNode)->SetOldRegion(ns); } (*newNode)->FreeMappedGroups(); (*newNode)->SetRoomOffset(0); break; } case NOK_DIAL_TIMEOUT: { (*newNode)->SetDialTimeout(atoi(words[1])); break; } case NOK_REQUEST: { (*newNode)->SetRequest(atoi(words[1])); break; } case NOK_WAIT_TIMEOUT: { (*newNode)->SetWaitTimeout(atoi(words[1])); break; } case NOK_AUTOROOM: { (*newNode)->SetAutoRoom(atoi(words[1])); break; } case NOK_VERBOSE: { (*newNode)->SetDefaultVerbose(); const char **verbosekeywords = (const char **) nddd->next->next->next->aux; for (int j = 1; j < count; j++) { if (SameString(words[j], getnodemsg(39))) { (*newNode)->SetDefaultVerbose(); } else if (SameString(words[j], getnodemsg(40))) { (*newNode)->SetDefaultVerbose(); (*newNode)->SetVerbose(NCV_FILE69INFULL, TRUE); (*newNode)->SetVerbose(NCV_NOACCESS, TRUE); } else if (SameString(words[j], getnodemsg(41))) { (*newNode)->SetDefaultVerbose(); (*newNode)->SetVerbose(NCV_FILE69INFULL, TRUE); (*newNode)->SetVerbose(NCV_NOACCESS, TRUE); (*newNode)->SetVerbose(NCV_ROOMCREATED, TRUE); (*newNode)->SetVerbose(NCV_ROOMNOTCREATED, TRUE); (*newNode)->SetVerbose(NCV_NETIDNOTFOUND, TRUE); (*newNode)->SetVerbose(NCV_NONETIDONSYSTEM, TRUE); } else { const char *Keyword; Bool NewSetting; if (words[j][0] == '!') { Keyword = words[j] + 1; NewSetting = FALSE; } else { Keyword = words[j]; NewSetting = TRUE; } NCV_Type TestType; for (TestType = (NCV_Type) 0; TestType < NCV_MAX; TestType = (NCV_Type) (TestType + 1)) { if (SameString(Keyword, verbosekeywords[TestType])) { (*newNode)->SetVerbose(TestType, NewSetting); break; } } if (TestType == NCV_MAX) { if (SameString(Keyword, getnodemsg(13))) { // ALL for (TestType = (NCV_Type) 0; TestType < NCV_MAX; TestType = (NCV_Type) (TestType + 1)) { (*newNode)->SetVerbose(TestType, NewSetting); } } else { TWcPrintf(getnodemsg(12), getnodemsg(8), ltoac(lineno), words[0], Keyword); TWdoccr(); } } } } break; } case NOK_CHAT: { (*newNode)->SetDefaultChat(); const char **chatkeywords = (const char **) nddd->next->next->next->next->aux; for (int j = 1; j < count; j++) { const char *Keyword; Bool NewSetting; if (words[j][0] == '!') { Keyword = words[j] + 1; NewSetting = FALSE; } else { Keyword = words[j]; NewSetting = TRUE; } NCC_Type TestType; for (TestType = (NCC_Type) 0; TestType < NCC_MAX; TestType = (NCC_Type) (TestType + 1)) { if (SameString(Keyword, chatkeywords[TestType])) { (*newNode)->SetChat(TestType, NewSetting); break; } } if (TestType == NCV_MAX) { if (SameString(Keyword, getnodemsg(13))) { // ALL for (TestType = (NCC_Type) 0; TestType < NCC_MAX; TestType = (NCC_Type) (TestType + 1)) { (*newNode)->SetChat(TestType, NewSetting); } } else { TWcPrintf(getnodemsg(12), getnodemsg(8), ltoac(lineno), words[0], Keyword); TWdoccr(); } } } break; } case NOK_REDIAL: { (*newNode)->SetRedial(atoi(words[1])); break; } case NOK_ROOM: { (*newNode)->SetRoomOffset(pos); fclose(fBuf); dump_node_ddata(); return (TRUE); } case NOK_GROUP: { if (!(*newNode)->AddMappedGroups(words[1], words[2])) { TWcPrintf(getnodemsg(10), words[1]); TWdoccr(); } if (strlen(words[1]) > LABELSIZE) { TWcPrintf(getnodemsg(1), getnodemsg(8), ltoac(lineno), nodekeywords[i], LABELSIZE + 1); TWdoccr(); } if (strlen(words[2]) > LABELSIZE) { TWcPrintf(getnodemsg(1), getnodemsg(8), ltoac(lineno), nodekeywords[i], LABELSIZE + 1); TWdoccr(); } break; } case NOK_GATEWAY: { (*newNode)->SetGateway(atoi(words[1])); break; } case NOK_FETCH: { (*newNode)->SetFetch(atoi(words[1])); break; } case NOK_NETFAIL: { (*newNode)->SetNetFail(atoi(words[1])); break; } case NOK_OUTPUTPACE: { (*newNode)->SetOutputPace(atoi(words[1])); break; } case NOK_IPADDRESS: { #ifdef WINCIT (*newNode)->SetIpAddress(words[1]); if (strlen(words[1]) > 255) { TWcPrintf(getnodemsg(1), getnodemsg(8), ltoac(lineno), nodekeywords[i], 256); TWdoccr(); } #endif break; } case NOK_IPPORT: { #ifdef WINCIT (*newNode)->SetIpPort(atoi(words[1])); #endif break; } default: { TWcPrintf(getnodemsg(11), getnodemsg(8), ltoac(lineno), words[0]); TWdoccr(); break; } } pos = ftell(fBuf); } fclose(fBuf); if (!FoundOurEntry && !option && debug) { TWwDoCR(W); TWwPrintf(W, getmsg(206), NameOrAddrToFind); TWwDoCR(W); } dump_node_ddata(); if (option) { return (TRUE); } else { return (FoundOurEntry); } }
/** @brief Parse a JSON string, with no decoding of classname hints. @param s Pointer to the JSON string to parse. @return A pointer to the resulting JSON object, or NULL on error. This function is similar to jsonParse(), except that it does not give any special treatment to a JSON_HASH with the JSON_CLASS_KEY tag. The calling code is responsible for freeing the resulting jsonObject. */ jsonObject* jsonParseRaw( const char* s ) { return parse_it( s, 0 ); }
/** @brief Parse a JSON string, with decoding of classname hints. @param str Pointer to the JSON string to parse. @return A pointer to the resulting JSON object, or NULL on error. If any node in the jsonObject tree is of type JSON_HASH, with a tag of JSON_CLASS_KEY and another tag of JSON_DATA_KEY, the parser will collapse a level. The subobject tagged with JSON_DATA_KEY will replace the JSON_HASH, and the string tagged as JSON_CLASS_KEY will be stored as its classname. If there is no tag of JSON_DATA_KEY, the hash will be replaced by a jsonObject of type JSON_NULL. The calling code is responsible for freeing the resulting jsonObject. */ jsonObject* jsonParse( const char* str ) { return parse_it( str, 1 ); }
/** @brief Parse a JSON string received as a printf-style format string. @param str A printf-style format string. Subsequent arguments, if any, are formatted and inserted into the JSON string before parsing. @return A pointer to the resulting JSON object, or NULL on error. Unlike jsonParse(), this function does not give any special treatment to a JSON_HASH with tags JSON_CLASS_KEY or JSON_DATA_KEY. The calling code is responsible for freeing the resulting jsonObject. */ jsonObject* jsonParseFmt( const char* str, ... ) { if( !str ) return NULL; VA_LIST_TO_STRING( str ); return parse_it( VA_BUF, 0 ); }
void TERMWINDOWMEMBER setdefaultconfig(Bool KeepTerm) { int oldATT[ATTR_NUM]; oldATT[ATTR_NORMAL] = CurrentUser->GetAttribute(ATTR_NORMAL); oldATT[ATTR_BLINK] = CurrentUser->GetAttribute(ATTR_BLINK); oldATT[ATTR_REVERSE] = CurrentUser->GetAttribute(ATTR_REVERSE); oldATT[ATTR_BOLD] = CurrentUser->GetAttribute(ATTR_BOLD); oldATT[ATTR_UNDERLINE] = CurrentUser->GetAttribute(ATTR_UNDERLINE); prevChar = ' '; // why here? CurrentUser->Clear(); // set all default defaults... CurrentUser->SetWidth(80); CurrentUser->SetCredits(3600); CurrentUser->SetLinefeeds(TRUE); CurrentUser->SetOldToo(TRUE); CurrentUser->SetNetUser(TRUE); CurrentUser->SetViewRoomDesc(TRUE); CurrentUser->SetEnterBorders(TRUE); CurrentUser->SetViewTitleSurname(TRUE); CurrentUser->SetViewSubjects(TRUE); CurrentUser->SetViewSignatures(TRUE); CurrentUser->SetMinibin(TRUE); CurrentUser->SetViewRoomInfoLines(TRUE); CurrentUser->SetViewHallDescription(TRUE); CurrentUser->SetViewBorders(TRUE); CurrentUser->SetSeeOwnChats(TRUE); CurrentUser->SetHearLaughter(TRUE); if (!KeepTerm) { CurrentUser->SetDefaultColors(TermCap->IsColor()); } else { CurrentUser->SetAttribute(ATTR_NORMAL, oldATT[ATTR_NORMAL]); CurrentUser->SetAttribute(ATTR_BLINK, oldATT[ATTR_BLINK]); CurrentUser->SetAttribute(ATTR_REVERSE, oldATT[ATTR_REVERSE]); CurrentUser->SetAttribute(ATTR_BOLD, oldATT[ATTR_BOLD]); CurrentUser->SetAttribute(ATTR_UNDERLINE, oldATT[ATTR_UNDERLINE]); } CurrentUser->SetPromptFormat(cfg.prompt); // "%n^A2%r%e" CurrentUser->SetDateStamp(cfg.datestamp); // "%x %X %p" CurrentUser->SetVerboseDateStamp(cfg.vdatestamp); // "%A %x %X %p" CurrentUser->SetNetPrefix(cfg.netPrefix); // "3*0" CurrentUser->SetMorePrompt(cfg.moreprompt); // "<more>" if (!KeepTerm) { setdefaultTerm(TT_DUMB); } if (cfg.accounting) { CurrentUserAccount->Negotiate(CurrentUser); } changedir(cfg.homepath); discardable *du = readData(8, 0, 0); if (du) { FILE *defusr; if ((defusr = fopen(citfiles[C_DEFUSER_CIT], FO_R)) != NULL) { const char **duk = (const char **) du->aux; char line[90]; char *words[256]; while (fgets(line, 90, defusr) != NULL) { if (line[0] != '#') { continue; } const int count = parse_it(words, line); if (count > 1) { int i; for (i = 0; i < DUK_NUM; i++) { if (SameString(words[0] + 1, duk[i])) { break; } } switch (i) { case DUK_FORWARD: { CurrentUser->SetForwardAddr(words[1]); break; } case DUK_SURNAME: { CurrentUser->SetSurname(words[1]); break; } case DUK_TITLE: { CurrentUser->SetTitle(words[1]); break; } case DUK_BOLD: { CurrentUser->SetAttribute(ATTR_BOLD, atoi(words[1])); break; } case DUK_NULLS: { CurrentUser->SetNulls(atoi(words[1])); break; } case DUK_WIDTH: { CurrentUser->SetWidth(atoi(words[1])); break; } case DUK_CREDITS: { CurrentUser->SetCredits(60 * atol(words[1])); break; } case DUK_INVERSE: { CurrentUser->SetAttribute(ATTR_REVERSE, atoi(words[1])); break; } case DUK_BLINK: { CurrentUser->SetAttribute(ATTR_BLINK, atoi(words[1])); break; } case DUK_UNDERLINE: { CurrentUser->SetAttribute(ATTR_UNDERLINE, atoi(words[1])); break; } case DUK_NORMAL: { CurrentUser->SetAttribute(ATTR_NORMAL, atoi(words[1])); break; } case DUK_PROTOCOL: { CurrentUser->SetDefaultProtocol(words[1][0]); break; } case DUK_PROMPT: { CurrentUser->SetPromptFormat(words[1]); break; } case DUK_DSTAMP: { CurrentUser->SetDateStamp(words[1]); break; } case DUK_VDSTAMP: { CurrentUser->SetVerboseDateStamp(words[1]); break; } case DUK_SIGNATURE: { CurrentUser->SetSignature(words[1]); break; } case DUK_NETPREFIX: { CurrentUser->SetNetPrefix(words[1]); break; } case DUK_ADDR1: { CurrentUser->SetMailAddr1(words[1]); break; } case DUK_ADDR2: { CurrentUser->SetMailAddr2(words[1]); break; } case DUK_ADDR3: { CurrentUser->SetMailAddr3(words[1]); break; } case DUK_POOP: { CurrentUser->SetPoopcount(atol(words[1])); break; } case DUK_UCMASK: { CurrentUser->SetUpperOnly(atoi(words[1])); break; } case DUK_EXPERT: { CurrentUser->SetExpert(atoi(words[1])); break; } case DUK_AIDE: { CurrentUser->SetAide(atoi(words[1])); break; } case DUK_TABS: { CurrentUser->SetTabs(atoi(words[1])); break; } case DUK_OLDTOO: { CurrentUser->SetOldToo(atoi(words[1])); break; } case DUK_UNLISTED: { CurrentUser->SetUnlisted(atoi(words[1])); break; } case DUK_PERMANENT: { CurrentUser->SetPermanent(atoi(words[1])); break; } case DUK_SYSOP: { CurrentUser->SetSysop(atoi(words[1])); break; } case DUK_NODE: { CurrentUser->SetNode(atoi(words[1])); break; } case DUK_NOACCOUNT: { CurrentUser->SetAccounting(!atoi(words[1])); break; } case DUK_NOMAIL: { CurrentUser->SetMail(!atoi(words[1])); break; } case DUK_ROOMTELL: { CurrentUser->SetViewRoomDesc(atoi(words[1])); break; } case DUK_BORDERS: { CurrentUser->SetEnterBorders(atoi(words[1])); break; } case DUK_VERIFIED: { CurrentUser->SetVerified(!!atoi(words[1])); break; } case DUK_SURNAMLOK: { CurrentUser->SetSurnameLocked(atoi(words[1])); break; } case DUK_LOCKHALL: { CurrentUser->SetDefaultHallLocked(atoi(words[1])); break; } case DUK_DISPLAYTS: { CurrentUser->SetViewTitleSurname(atoi(words[1])); break; } case DUK_SUBJECTS: { CurrentUser->SetViewSubjects(atoi(words[1])); break; } case DUK_SIGNATURES: { CurrentUser->SetViewSignatures(atoi(words[1])); break; } case DUK_DEFAULTHALL: { CurrentUser->SetDefaultHall(words[1]); break; } case DUK_LINESSCREEN: { CurrentUser->SetLinesPerScreen(atoi(words[1])); break; } case DUK_FORWARDNODE: { CurrentUser->SetForwardAddrNode(words[1]); if (*words[1]) { CurrentUser->SetForwardToNode(TRUE); } break; } case DUK_LFMASK: { CurrentUser->SetLinefeeds(atoi(words[1])); break; } case DUK_PROBLEM: { CurrentUser->SetProblem(atoi(words[1])); break; } case DUK_NETUSER: { CurrentUser->SetNetUser(atoi(words[1])); break; } case DUK_NEXTHALL: { CurrentUser->SetAutoNextHall(atoi(words[1])); break; } case DUK_PSYCHO: { CurrentUser->SetPsycho(atoi(words[1])); break; } case DUK_TWIRLY: { CurrentUser->SetTwirly(atoi(words[1])); break; } case DUK_VERBOSE: { CurrentUser->SetAutoVerbose(atoi(words[1])); break; } case DUK_MSGPAUSE: { CurrentUser->SetPauseBetweenMessages(atoi(words[1])); break; } case DUK_MINIBIN: { CurrentUser->SetMinibin(atoi(words[1])); break; } case DUK_MSGCLS: { CurrentUser->SetClearScreenBetweenMessages(atoi(words[1])); break; } case DUK_ROOMINFO: { CurrentUser->SetViewRoomInfoLines(atoi(words[1])); break; } case DUK_HALLTELL: { CurrentUser->SetViewHallDescription(atoi(words[1])); break; } case DUK_VERBOSECONT: { CurrentUser->SetVerboseContinue(atoi(words[1])); break; } case DUK_VIEWCENSOR: { CurrentUser->SetViewCensoredMessages(atoi(words[1])); break; } case DUK_SEEBORDERS: { CurrentUser->SetViewBorders(atoi(words[1])); break; } case DUK_OUT300: { CurrentUser->SetOut300(atoi(words[1])); break; } case DUK_LOCKUSIG: { CurrentUser->SetUserSignatureLocked(atoi(words[1])); break; } case DUK_HIDEEXCL: { CurrentUser->SetHideMessageExclusions(atoi(words[1])); break; } case DUK_NODOWNLOAD: { CurrentUser->SetDownload(!atoi(words[1])); break; } case DUK_NOUPLOAD: { CurrentUser->SetUpload(!atoi(words[1])); break; } case DUK_NOCHAT: { CurrentUser->SetChat(!atoi(words[1])); break; } case DUK_PRINTFILE: { CurrentUser->SetPrintFile(atoi(words[1])); break; } case DUK_REALNAME: { CurrentUser->SetRealName(words[1]); break; } case DUK_PHONENUM: { CurrentUser->SetPhoneNumber(words[1]); break; } case DUK_SPELLCHECK: { CurrentUser->SetSpellCheckMode(atoi(words[1])); break; } case DUK_NOMAKEROOM: { CurrentUser->SetMakeRoom(!atoi(words[1])); break; } case DUK_VERBOSELO: { CurrentUser->SetVerboseLogOut(atoi(words[1])); break; } case DUK_CONFSAVE: { CurrentUser->SetConfirmSave(atoi(words[1])); break; } case DUK_CONFABORT: { CurrentUser->SetConfirmAbort(atoi(words[1])); break; } case DUK_CONFEOABORT: { CurrentUser->SetConfirmNoEO(atoi(words[1])); break; } case DUK_USEPERSONAL: { CurrentUser->SetUsePersonalHall(atoi(words[1])); break; } case DUK_YOUAREHERE: { CurrentUser->SetYouAreHere(atoi(words[1])); break; } case DUK_IBMROOM: { CurrentUser->SetIBMRoom(atoi(words[1])); break; } case DUK_WIDEROOM: { CurrentUser->SetWideRoom(atoi(words[1])); break; } case DUK_MUSIC: { CurrentUser->SetMusic(atoi(words[1])); break; } case DUK_MOREPROMPT: { CurrentUser->SetMorePrompt(words[1]); break; } case DUK_NUMUSERSHOW: { CurrentUser->SetNumUserShow(atoi(words[1])); break; } case DUK_CALLLIMIT: { CurrentUser->SetCallLimit(atoi(words[1])); break; } case DUK_CHECKAPS: { CurrentUser->SetCheckApostropheS(atoi(words[1])); break; } case DUK_CHECKALLCAPS: { CurrentUser->SetCheckAllCaps(atoi(words[1])); break; } case DUK_CHECKDIGITS: { CurrentUser->SetCheckDigits(atoi(words[1])); break; } case DUK_EXCLUDEENCRYPTED: { CurrentUser->SetExcludeEncryptedMessages(atoi(words[1])); break; } case DUK_SHOWCOMMAS: { CurrentUser->SetViewCommas(atoi(words[1])); break; } case DUK_PUNPAUSES: { CurrentUser->SetPUnPauses(atoi(words[1])); break; } case DUK_KUSER: { CurrentUser->AddKill(KF_USER, words[1]); break; } case DUK_KTEXT: { CurrentUser->AddKill(KF_TEXT, words[1]); break; } case DUK_KNODE: { CurrentUser->AddKill(KF_NODE, words[1]); break; } case DUK_KREG: { CurrentUser->AddKill(KF_REGION, words[1]); break; } case DUK_TUSER: { if (count > 2) { CurrentUser->AddTagUser(words[1], words[2]); } break; } case DUK_DICTWORD: { CurrentUser->AddWordToDictionary(words[1]); break; } case DUK_FINGER: { CurrentUser->SetFinger(words[1]); break; } case DUK_USERDEF: { if (count > 2) { CurrentUser->SetUserDefined(words[1], words[2]); } break; } case DUK_REPLACE: { if (count > 2) { CurrentUser->AddReplace(words[1], words[2]); } break; } case DUK_ROMAN: { CurrentUser->SetRoman(atoi(words[1])); break; } case DUK_SUPERSYSOP: { CurrentUser->SetSuperSysop(atoi(words[1])); break; } case DUK_BUNNY: { CurrentUser->SetBunny(atoi(words[1])); break; } case DUK_SSE_LOGONOFF: { CurrentUser->SetSELogOnOff(atoi(words[1])); break; } case DUK_SSE_NEWMSG: { CurrentUser->SetSENewMessage(atoi(words[1])); break; } case DUK_SSE_EXCLMSG: { CurrentUser->SetSEExclusiveMessage(atoi(words[1])); break; } case DUK_SSE_CHATALL: { CurrentUser->SetSEChatAll(atoi(words[1])); break; } case DUK_SSE_CHATROOM: { CurrentUser->SetSEChatRoom(atoi(words[1])); break; } case DUK_SSE_CHATGROUP: { CurrentUser->SetSEChatGroup(atoi(words[1])); break; } case DUK_SSE_CHATUSER: { CurrentUser->SetSEChatUser(atoi(words[1])); break; } case DUK_SSE_RMINOUT: { CurrentUser->SetSERoomInOut(atoi(words[1])); break; } case DUK_TERMTYPE: { CurrentUser->SetTermType(words[1]); TermCap->Load(words[1]); break; } case DUK_BANNED: { CurrentUser->SetBanned(atoi(words[1])); break; } case DUK_KILLOWN: { CurrentUser->SetKillOwn(atoi(words[1])); break; } case DUK_SEEOWNCHATS: { CurrentUser->SetSeeOwnChats(atoi(words[1])); break; } case DUK_ERASEPROMPT: { CurrentUser->SetErasePrompt(atoi(words[1])); break; } case DUK_AUTOIDLESECONDS: { CurrentUser->SetAutoIdleSeconds(atoi(words[1])); break; } case DUK_SSE_MSGSOMEWHERE: { CurrentUser->SetHearLaughter(atoi(words[1])); break; } default: { doccr(); cPrintf(getmsg(21), citfiles[C_DEFUSER_CIT], words[0]); doccr(); break; } } } } fclose(defusr); } discardData(du); } }
void cyclesignature(void) { FILE *fBuf; char line[256]; char *words[256]; Bool found = FALSE; char path[80]; // there is only one signature line, so get out and use it if (cfg.sig_current_pos == LONG_MAX) { return; } sprintf(path, sbs, cfg.homepath, citfiles[C_CONFIG_CIT]); if ((fBuf = fopen(path, FO_R)) == NULL) // ASCII mode { return; } fseek(fBuf, cfg.sig_current_pos, SEEK_SET); Bool HaveStartedOver = FALSE; for (; !found;) { // if end of file cycle back up if (fgets(line, 254, fBuf) == NULL) { if (!HaveStartedOver) { fseek(fBuf, cfg.sig_first_pos, SEEK_SET); HaveStartedOver = TRUE; } else { found = TRUE; // not found, but this breaks us out of the loop } continue; } cfg.sig_current_pos = ftell(fBuf); if (line[0] != '#') { continue; } if (strnicmp(line, getmsg(137), strlen(getmsg(137))) != SAMESTRING) { // okay we've gone past the last signature, cycle back up if (!HaveStartedOver) { fseek(fBuf, cfg.sig_first_pos, SEEK_SET); HaveStartedOver = TRUE; } else { found = TRUE; // not found, but this breaks us out of the loop } continue; } else { found = TRUE; } parse_it(words, line); CopyStringToBuffer(cfg.nodeSignature, words[1]); cfg.sig_current_pos = ftell(fBuf); } fclose(fBuf); }
void messWithShareList (uchar bUsage, label roomname) { struct messNode nodeArray[MAXDIRECT] ; int i, j, iNode, iTopNode, iOn ; uchar fKeyFound, fAnyPrinted, fQuit, fDisplayMenu ; char ch, oldEcho, path[255], buf[255], *lpch, *lpstr, aHotKeys[] = "BCDEFGHIJKLMNOPQRTUVWXYZ1234567890!#$%&*(", *words[256]; int hFile ; /* Initialize the array. */ for (i = 0; i < MAXDIRECT; i++) { strcpy (nodeArray[i].nodeName, '\0') ; nodeArray[i].fShared = FALSE ; nodeArray[i].bHotKey = (uchar) 0 ; nodeArray[i].bHotKeyPos = (uchar) 0 ; } /* In one single pass, we're going to read the NODES file and fill out */ /* our array based on all the information we find there! */ sprintf (path, "%s\\NODES.CIT", cfg.homepath) ; hFile = sopen (path, O_TEXT | O_RDONLY, SH_DENYNO) ; if (-1 == hFile) crashout ("Problem opening NODES.CIT.") ; iTopNode = -1 ; while ( !eof(hFile) ) { if (!sfgets (buf, 255, hFile)) break ; /* Error reading file. */ if ('#' != buf[0]) /* It's not a keyword. */ continue ; if (strnicmp (buf, "#NODE", 5) == SAMESTRING) { parse_it (words, buf) ; if (words[1] == NULL) /* Invalid #NODE entry. */ continue ; /* We have a new node and its name! */ ++iTopNode ; strcpy (nodeArray[iTopNode].nodeName, words[1]) ; } else { if (strnicmp (buf, "#ROOM", 5) != SAMESTRING) continue ; if (-1 == iTopNode) /* We don't have a node yet. */ continue ; parse_it (words, buf) ; if (stricmp (words[1], roomname) == SAMESTRING) nodeArray[iTopNode].fShared = TRUE ; } } close (hFile) ; /* For the short, non-interactive output, just spew it out and quit. */ if (SHORT_SEE_NO_MODIFY == bUsage) { if (-1 == iTopNode) mPrintf ("(No nodes in NODES.CIT.)") ; else { iOn = 0 ; fAnyPrinted = FALSE ; while (iOn <= iTopNode) { if (TRUE == nodeArray[iOn].fShared) { if (fAnyPrinted) mPrintf ("3, 0%s", nodeArray[iOn].nodeName) ; else { mPrintf ("%s", nodeArray[iOn].nodeName) ; fAnyPrinted = TRUE ; } } ++iOn ; } if (fAnyPrinted) mPrintf ("3.0") ; } return ; } if (SEE_WITH_MODIFY == bUsage) { /* If we found more nodes than we can hotkey, say so and abort. */ if (iTopNode >= (int) strlen (aHotKeys)) { mPrintf ("Uh-oh! There are too many nodes in the userlog to use this function.") ; doCR() ; return ; } /* Hotkeys are determined by a priority system. First, we try to */ /* get the first character of the node name. Second, we try for */ /* the first character following every space in the name. Third, */ /* we try every character in the name. Last, we scan the entire */ /* hotkey string until we find an unused key. */ for (iNode = 0; iNode <= iTopNode; iNode++) { fKeyFound = FALSE ; /* PLAN ONE: Try for the first character. */ ch = (char) toupper (*nodeArray[iNode].nodeName) ; lpch = strchr (aHotKeys, ch) ; if (lpch) /* If char = valid hotkey... */ { nodeArray[iNode].bHotKey = *lpch ; nodeArray[iNode].bHotKeyPos = 0 ; *lpch = FILLED ; /* Ptr into aHotKeys */ continue ; /* Do the next node. */ } /* PLAN TWO: Try for the first letter of every word. Since i */ /* starts at one, it's ok to check the previous character for */ /* a space. */ lpstr = nodeArray[iNode].nodeName ; i = 1 ; while (lpstr[i]) /* While we're not on the final NULL... */ { if ( ' ' == lpstr[i-1] ) /* Is the prev char a space? */ { ch = (char) toupper (lpstr[i]) ; lpch = strchr (aHotKeys, ch) ; if (lpch) /* Valid chr? */ { nodeArray[iNode].bHotKey = *lpch ; nodeArray[iNode].bHotKeyPos = (uchar) i ; *lpch = FILLED ; /* Ptr into aHotKeys */ fKeyFound = TRUE ; /* Signal release from for iter.*/ break ; /* Releases from while loop. */ } } ++i ; } /* If the above loop found a key, move on to the next node. */ if (fKeyFound) continue ; /* PLAN THREE: Check every single character in the string for */ /* a valid hot key. */ i = 0 ; while (lpstr[i]) /* While we're not on the final NULL... */ { ch = (char) toupper (lpstr[i]) ; lpch = strchr (aHotKeys, ch) ; if (lpch) /* Valid chr? */ { nodeArray[iNode].bHotKey = *lpch ; nodeArray[iNode].bHotKeyPos = (uchar) i ; *lpch = FILLED ; /* Ptr into aHotKeys */ fKeyFound = TRUE ; /* Signal release from for iter. */ break ; /* Releases from while loop. */ } ++i ; } /* If the above loop found a key, move on to the next node. */ if (fKeyFound) continue ; /* PLAN FOUR: Give the node the first available hot key. */ /* Checking done previously assures that we'll get one. */ i = 0 ; while (FILLED == aHotKeys[i]) ++i ; nodeArray[iNode].bHotKey = aHotKeys[i] ; nodeArray[iNode].bHotKeyPos = NOT_IN_STRING ; aHotKeys[i] = FILLED ; } fDisplayMenu = TRUE ; fQuit = FALSE ; for (;;) { if (fDisplayMenu) { doCR () ; for (iNode = 0; iNode <= iTopNode; iNode++) { strcpy (buf, ".........................") ; lpstr = nodeArray[iNode].nodeName ; i = j = 0 ; while (lpstr[i] != '\0') /* Doesn't copy the NULL */ { if ( i == (int) nodeArray[iNode].bHotKeyPos) /* Turn on bold */ { buf[j] = '' ; buf[j+1] = '3' ; buf[j+2] = lpstr[i] ; buf[j+3] = '' ; buf[j+4] = '0' ; j += 5 ; } else { buf[j] = lpstr[i] ; ++j ; } ++i ; } mPrintf ("<3%c0> %s %s", nodeArray[iNode].bHotKey, buf, nodeArray[iNode].fShared ? "YES" : "No") ; doCR() ; } } /* Take user input. */ doCR() ; mPrintf("<3S0> to save, <3A0> to abort."); doCR(); fDisplayMenu = (BOOL)(!expert) ; outFlag = IMPERVIOUS; doCR(); mPrintf("2Add/Drop:0 "); oldEcho = echo; echo = NEITHER; ch = (char) iChar(); echo = oldEcho; if (!((whichIO == CONSOLE) || gotCarrier())) return; switch(toupper(ch)) { case 'A': mPrintf("Abort"); doCR(); if (getYesNo("Abort", TRUE)) return; break; case 'S': mPrintf("Save"); doCR(); if (getYesNo("Save", TRUE)) { saveNewReality(nodeArray, roomname, iTopNode) ; return ; } break ; case '\r': case '\n': case '?' : mPrintf("Menu"); doCR(); fDisplayMenu = TRUE; break; default: /* Check if for hotkey and toggle right entry. */ for (i = 0; i <= iTopNode; i++) if (toupper(ch) == nodeArray[i].bHotKey) { nodeArray[i].fShared = (uchar) !nodeArray[i].fShared ; mPrintf ("%s %s", nodeArray[i].nodeName, nodeArray[i].fShared ? "added." : "dropped.") ; doCR() ; break ; } /* If it fails to break above, it's not valid input. */ if (i > iTopNode) { mPrintf("%c ? for help", ch); doCR(); break ; } } } /* This is in the right place. */ } }
/* -------------------------------------------------------------------- */ void ReadExternalCit(void) { FILE *fBuf; char line[257]; char *words[256]; int count; if ((fBuf = fopen(externalCit, "r")) == NULL) /* ASCII mode */ { printf("Cannot find %s!", externalCit); exit(69); } else { int i, lineNo = 0; while (fgets(line, 256, fBuf) != NULL) { lineNo++; if (line[0] != '#') { continue; } count = parse_it(words, line); if (SameString(words[0], "#PROTOCOL")) { protocols *theProt; theProt = (protocols *) addLL((void **) &protList, sizeof(*theProt)); if (theProt) { CopyStringToBuffer(theProt->name, words[1], LABELSIZE); theProt->batch = !!atoi(words[2]); theProt->block = atoi(words[3]); CopyStringToBuffer(theProt->rcv, words[4], 127); CopyStringToBuffer(theProt->snd, words[5], 127); if (count <= 6 || words[6][0] == '\0') { theProt->autoDown[0] = '\0'; } else { CopyStringToBuffer(theProt->autoDown, words[6], LABELSIZE); } if (count > 7) { CopyStringToBuffer(theProt->respDown, words[7], 127); } } else { printf("Not enough memory for #PROTOCOL \"%s\"", words[1]); printf("\n"); } } } fclose(fBuf); } }
Bool TERMWINDOWMEMBER parseLine(char *line) { int i, j, k; char *words[128]; char newline[82]; char done; const int count = parse_it(words, line); i = -1; while (++i < count) { switch (tolower(*words[i++])) { case 'd': { if (debug) { OC.ansiattr = cfg.wattr; cPrintf(getdbmsg(6), words[i], words[i + 1], words[i + 2]); OC.ansiattr = cfg.attr; cPrintf(spc); } else { cPrintf(getmsg(433)); } const protocols *theProt = GetProtocolByKey(words[i][0], TRUE); if (!theProt) { return (FALSE); } wxrcv(words[i + 1], words[i + 2], theProt); i += 2; break; } case 'p': { if (debug) { OC.ansiattr = cfg.wattr; cPrintf(getdbmsg(7), words[i]); OC.ansiattr = cfg.attr; cPrintf(spc); } else { cPrintf(getmsg(433)); } netpause(atoi(words[i]) * 100); break; } case 'r': { if (debug) { OC.ansiattr = cfg.wattr; cPrintf(getdbmsg(8), words[i], words[i+1], words[i+2]); OC.ansiattr = cfg.attr; cPrintf(spc); } else { cPrintf(getmsg(433)); } k = atoi(words[i+2]); for (done = FALSE, j = 0; j < k && !done; j++) { if (debug) { OC.ansiattr = cfg.wattr; cPrintf(getdbmsg(9), words[i]); OC.ansiattr = cfg.attr; cPrintf(spc); } else { cPrintf(getmsg(433)); } if (!wait_for(words[i], node->GetWaitTimeout())) { if (debug) { OC.ansiattr = cfg.wattr; cPrintf(getdbmsg(10), words[i+1]); OC.ansiattr = cfg.attr; cPrintf(spc); } else { cPrintf(getmsg(433)); } CommPort->OutString(words[i + 1], node->GetOutputPace()); } else { done = TRUE; } } i += 2; if (!done) { return (FALSE); } break; } case 's': { if (debug) { OC.ansiattr = cfg.wattr; cPrintf(getdbmsg(10), words[i]); OC.ansiattr = cfg.attr; cPrintf(spc); } else { cPrintf(getmsg(433)); } CommPort->OutString(words[i], node->GetOutputPace()); break; } case 'u': { if (debug) { OC.ansiattr = cfg.wattr; cPrintf(getdbmsg(11), words[i], words[i + 1], words[i + 2]); OC.ansiattr = cfg.attr; cPrintf(spc); } else { cPrintf(getmsg(433)); } const protocols *theProt = GetProtocolByKey(words[i][0], TRUE); if (!theProt) { return (FALSE); } wxsnd(words[i + 1], words[i + 2], theProt, 0); i += 2; break; } case 'w': { if (debug) { OC.ansiattr = cfg.wattr; cPrintf(getdbmsg(9), words[i]); OC.ansiattr = cfg.attr; cPrintf(spc); } else { cPrintf(getmsg(433)); } if (!wait_for(words[i], node->GetWaitTimeout())) { return (FALSE); } break; } case '!': { RunApplication(words[i], NULL, TRUE, TRUE); break; } case '@': { FILE *file; if ((file = fopen(words[i], FO_R)) != NULL) { while (fgets(newline, 80, file)) { if (!parseLine(newline)) { fclose(file); return (FALSE); } } fclose(file); } else { return (FALSE); } break; } default: { OC.ansiattr = (uchar)(cfg.cattr | 128); cPrintf(getnetmsg(52), words[i-1], words[i]); OC.ansiattr = cfg.attr; cPrintf(spc); break; } } } return (TRUE); }