int neighbors (Pdb_map * pdb_map,int map_length, Chain_info * chain_info, int no_of_chains) {
int c, atom;
int atom1, atom2;
int residue1, residue2;
double x, y, z, dist, cutoff;
double avg, avg_bb;
int no_bb;
cutoff = 3.0;
for (c=0; c<no_of_chains;c++) {
for ( residue1=0; residue1<chain_info[c].number_of_residues-1; residue1++) {
for (atom1=chain_info[c].residue_start[residue1];
atom1<=chain_info[c].residue_end[residue1]; atom1++) {
for ( residue2=residue1+1; residue2<chain_info[c].number_of_residues; residue2++) {
for (atom2=chain_info[c].residue_start[residue2];
atom2<=chain_info[c].residue_end[residue2] ; atom2++) {
x = pdb_map[atom1].x- pdb_map[atom2].x;
y = pdb_map[atom1].y- pdb_map[atom2].y;
z = pdb_map[atom1].z- pdb_map[atom2].z;
dist = sqrt (x*x+y*y+z*z);
if ( dist <= cutoff ) {
pdb_map[atom1].no_of_neighbors++;
pdb_map[atom2].no_of_neighbors++;
}
} /* end atom2 loop*/
}/* end residue2 loop*/
}/* end atom1 loop*/
}/* end residue1 loop*/
}/* end chain loop*/
# if 1
avg = avg_bb = 0;
no_bb = 0;
for (atom=0; atom< map_length; atom++ ) {
//printf (" %6d %3d\n", atom, pdb_map[atom].no_of_neighbors);
avg += pdb_map[atom].no_of_neighbors;
if ( charcount(pdb_map[atom].name_atom,PDB_ATOM_ATOM_NAME_LEN) ==1 ){
avg_bb += pdb_map[atom].no_of_neighbors;
no_bb++;
}
}
printf (" avg no nbrs: %8.3f\n", avg/map_length);
printf (" avg no nbrs for backbone: %8.3f\n", avg_bb/no_bb);
# endif
return 0;
}
int main (int argc, char *argv[]) {
int count[26]={0};
char c;
// getchar() reads and returns one character from the keyboard
// returns -1 when it reads end-of-file character (^D in linux)
while (!feof(stdin)) {
c = getchar();
//putchar(c);
charcount(count,c);
}
charStat(count);
return EXIT_SUCCESS;
}
bool isAnagram(string s, string t) {
vector<int> charcount(26, 0);
for(int i =0; i< s.length(); i++) {
charcount[s[i] - 'a'] ++;
}
for(int i =0; i< t.length(); i++) {
charcount[t[i] - 'a'] --;
}
for(int i =0; i<charcount.size(); i++) {
if(charcount[i] != 0) {
return false;
}
}
return true;
}
//
// GetModuleName
//
// Gets the module file name as a full path, and extracts the file portion.
//
static void GetModuleName(void)
{
TCHAR *dot;
ZeroMemory(moduleFileName, sizeof(moduleFileName));
if(GetModuleFileName(NULL, moduleFileName, charcount(moduleFileName) - 2) <= 0)
lstrcpy(moduleFileName, _T("Unknown"));
fileName = ExtractFileName(moduleFileName);
lstrcpy(moduleName, fileName);
// find extension and remove it
if((dot = lstrrchr(moduleName, _T('.'))))
dot[0] = 0;
// put filename onto module path
lstrcpy(fileName, _T("CRASHLOG.TXT"));
}
/*
* Takes an array of strings and returns the string with the maximum number of occurences
* of a given character. In case of a tie, the first string is returned. If the array is
* empty or if the character does not exist in any of the strings, an empty string is returned.
*/
char* maxstring(char* str_arr[], int num, char c) {
int i;
int max = 0;
int index = -1;
if(str_arr == NULL)
return "";
for(i = 0; i < num; i++)
{
int cur_count = charcount(str_arr[i], c);
if(cur_count > max)
{
max = cur_count;
index = i;
}
}
if(index == -1)
return "";
return str_arr[index];
}
main()
{
char input1[SIZE];
char input2[SIZE];
char addinput1[23+SIZE]="First word entered is : ";
printf ("Please input a word.\n");
gets(input1);
printf ("\nPlease input another word.\n");
gets(input2);
if (input1[SIZE-1]!='\0')
{
input1[SIZE-1]='\0';
}//end if
if (input2[SIZE-1]!='\0')
{
input2[SIZE-1]='\0';
}//end if
if (strcmp(input1, input2)==0)
{
printf ("\nThe two words are identical.");
}
else
{
printf ("\nThe two words are not identical.");
}//end if
strcat(addinput1, input1);
printf ("\n\n%s", addinput1);
charcount(addinput1);
flushall();
getchar();
}//end main()
/*
* How it works -- if There are no parenthesis, it must be a
* foreach array command. If there are parenthesis, and there are
* exactly two commas, it must be a C-like for command, else it must
* must be an foreach word command
*/
void
foreach_handler(u_char *command, u_char *args, u_char *subargs)
{
u_char *temp = NULL;
u_char *placeholder;
u_char *temp2 = NULL;
malloc_strcpy(&temp, args);
placeholder = temp;
if (*temp == '(')
{
if ((temp2 = next_expr(&temp, '(')) == NULL) {
new_free(&placeholder);
return;
}
if (charcount(temp2, ',') == 2)
forcmd(command, args, subargs);
else
fe(command, args, subargs);
}
else
foreach(command, args, subargs);
new_free(&placeholder);
}
//
// PrintHeader
//
// Prints a header for the exception.
//
static void PrintHeader(void)
{
TCHAR *crashModuleFn = _T("Unknown");
MEMORY_BASIC_INFORMATION memoryInfo;
ZeroMemory(crashModulePath, sizeof(crashModulePath));
#ifdef _M_IX86
// Use VirtualQuery to retrieve the allocation base associated with the
// process's code address.
if(VirtualQuery((void *)contextRecord->Eip, &memoryInfo, sizeof(memoryInfo)))
{
if(GetModuleFileName((HINSTANCE)memoryInfo.AllocationBase,
crashModulePath, charcount(crashModulePath)-2) > 0)
{
crashModuleFn = ExtractFileName(crashModulePath);
}
}
LogPrintf(
_T("%s caused %s Exception (0x%08x)\r\nin module %s at %04x:%08x.\r\n\r\n"),
moduleName,
PhraseForException(exceptionRecord->ExceptionCode),
exceptionRecord->ExceptionCode,
crashModuleFn,
contextRecord->SegCs,
contextRecord->Eip);
#else
// FIXME: how to get crash module name and address on non-x86, x64?
LogPrintf(
_T("%s caused %s Exception (0x%08x)\r\n\r\n"),
moduleName,
PhraseForException(exceptionRecord->ExceptionCode),
exceptionRecord->ExceptionCode);
#endif
}
int main(void){
int intarray[] = {1,2,3,4,5,6,7,8};
char * chararray = "asdfghjkl";
intcount(intarray);
charcount(chararray);
}
static int handle_oper_vision(const char *from, char *cline, int *up_status)
{
char *fr, *for_, *temp, *temp2;
char *p;
int done_one = 0;
char *line;
unsigned long flags;
int dcount;
p = fr = for_ = temp = temp2 = NULL;
if (from_server == -1 || !(flags = get_server_ircop_flags(from_server)))
return 0;
line = LOCAL_COPY(cline);
if (!strncmp(line, "*** Notice -- ", 13)) line += 14, dcount = 14;
else if (!strncmp(line, "*** \002Notice\002 --", 15)) line += 16, dcount = 16;
done_one++;
/*
[ss]!irc.cs.cmu.edu D-line active for think[[email protected]]
*/
set_display_target(NULL, LOG_SNOTE);
if (!strncmp(line, "Received KILL message for ", 26))
{
char *q = line + 26;
int loc_check = 0;
for_ = next_arg(q, &q);
if (!end_strcmp(for_, ".", 1))
chop(for_, 1);
q += 5;
fr = next_arg(q, &q);
q += 6;
check_orig_nick(for_);
if (strchr(fr, '.'))
{
nick_collisions++;
if (!(flags & NICK_COLLIDE))
goto done;
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_NICK_COLLISION_FSET), "%s %s %s %s", update_clock(GET_TIME), fr, for_, q));
}
else
{
oper_kills++;
if (!(flags & NICK_KILL))
goto done;
if ((temp2 = next_arg(q, &q)))
loc_check = charcount(temp2, '!');
if (q && *q)
q++; chop(q, 1);
if (loc_check <= 2)
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_KILL_LOCAL_FSET), "%s %s %s %s", update_clock(GET_TIME), fr, for_, q));
else
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_KILL_FSET), "%s %s %s %s", update_clock(GET_TIME), fr, for_, q));
}
(*up_status)++;
}
else if (!strncmp(line, "Nick collision on", 17) || !strncmp(line, "Nick change collision on", 24))
{
#if 0
irc.BitchX.com *** Notice -- Nick collision on nickserv(irc.distracted.net <-
irc.distracted.net[[email protected]])(both killed)
[BitchX] Nick collision llision killed on
#endif
nick_collisions++;
if (!(flags & NICK_COLLIDE))
goto done;
if (!strncmp(line+5, "change", 6))
p = line + 24;
else
p = line + 18;
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_NICK_COLLISION_FSET), "%s %s", update_clock(GET_TIME), p));
(*up_status)++;
}
else if (!strncmp(line, "IP# Mismatch:", 13))
{
if (!(flags & IP_MISMATCH))
goto done;
for_ = line + 14;
serversay(1, from_server, "%s", convert_output_format(" IP Mismatch %C$1-", "%s %s", update_clock(GET_TIME), for_));
}
else if (!strncmp(line, "Hacked ops on opless channel:", 29))
{
if (!(flags & HACK_OPS))
goto done;
for_ = line + 29;
serversay(1, from_server, "%s", convert_output_format(" Hacked ops on $0", "%s", for_));
}
else if (!strncmp(line, "connect failure:", 16))
{
client_connects++;
client_exits++;
if (!(flags & SERVER_CRAP))
goto done;
for_ = line + 16;
serversay(1, from_server, "%s", convert_output_format(" Connect failure %K[%n$0-%K]", "%s", for_));
}
else if (!strncmp(line, "Identd response differs", 22))
{
if (!(flags & IDENTD))
goto done;
for_ = line + 24;
serversay(1, from_server, "%s", convert_output_format(" Identd response differs %K[%C$1-%K]", "%s %s", update_clock(GET_TIME), for_));
}
else if (!strncmp(line, "Fake: ", 6)) /* MODE */
{
serv_fakes++;
if (!(flags & FAKE_MODE))
goto done;
p = line + 6;
if ((fr = next_arg(p, &temp)))
{
if (lookup_channel(fr, from_server, CHAN_NOUNLINK))
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_FAKE_FSET), "%s %s %s", update_clock(GET_TIME), fr, temp));
else
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_FAKE_FSET), "%s %s %s", update_clock(GET_TIME), fr, temp));
}
}
else if (!strncmp(line, "Unauthorized connection from",28))
{
serv_unauth++;
if (!(flags & UNAUTHS))
goto done;
for_ = line + 28;
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_UNAUTH_FSET), "%s %s", update_clock(GET_TIME), for_));
}
else if (!strncmp(line, "Too many connections from",25))
{
serv_unauth++;
if (!(flags & TOO_MANY))
goto done;
for_ = line + 25;
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_UNAUTH_FSET), "%s %s", update_clock(GET_TIME), for_));
}
else if (strstr(line, "Entering high-traffic mode -") || !strncmp(line, "still high-traffic mode -", 25))
{
char *q;
serv_split++;
if (!(flags & TRAFFIC))
goto done;
if (!strncmp(line, "Entering", 8))
{
p = line + 28;
for_ = next_arg(p, &p);
q = temp2 = p;
if (temp2)
{
chop(temp2, 1);
q = temp2+2;
}
}
else if (!strncmp(line+10, "Entering", 8))
{
p = line + 38;
for_ = next_arg(p, &p);
q = temp2 = p;
if (temp2)
{
chop(temp2, 1);
q = temp2+2;
}
}
else
{
p = line + 25;
for_ = next_arg(p, &p);
q = temp2 = p;
if (temp2)
{
chop(temp2, 1);
q = temp2+2;
}
}
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_TRAFFIC_HIGH_FSET), "%s %s %s", update_clock(GET_TIME), for_, q));
}
else if (!strncmp(line, "Resuming standard operation", 27))
{
serv_rejoin++;
if (!(flags & TRAFFIC))
goto done;
p = line + 27;
for_ = next_arg(p, &p);
if (for_ && *for_ == '-')
for_ = next_arg(p, &p);
temp = next_arg(p, &temp2);
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_TRAFFIC_NORM_FSET), "%s %s %s %s", update_clock(GET_TIME), for_, temp, temp2));
}
else if (wild_match("% is rehashing Server config*", line))
{
serv_rehash++;
if (!(flags & REHASH))
goto done;
p = line;
for_ = next_arg(p, &p);
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_REHASH_FSET), "%s %s", update_clock(GET_TIME), for_));
}
else if (wild_match("% added K-Line for *", line))
{
char *serv = NULL;
serv_klines++;
if (!(flags & KLINE))
goto done;
p = line;
for_ = next_arg(p, &p);
if (!strncmp(p, "from", 4))
{
next_arg(p, &p);
serv = next_arg(p, &p);
}
p += 17;
temp2 = next_arg(p, &temp);
if (++temp2)
chop(temp2, 1);
if (serv)
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_GLINE_FSET), "%s %s %s %s %s", update_clock(GET_TIME), for_, temp2, serv, temp));
else
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_KLINE_FSET), "%s %s %s %s", update_clock(GET_TIME), for_, temp2, temp));
}
else if (!strncmp(line, "Rejecting vlad/joh/com bot:", 27) || !strncmp(line+14, "Rejecting eggdrop bot:", 20) || !strncmp(line, "Rejecting ojnk/annoy bot", 24))
{
client_bot++;
if (!(flags & POSSIBLE_BOT))
goto done;
p = line + 10;
temp2 = next_arg(p, &p);
for_ = p + 4;
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_BOT_FSET), "%s %s %s", update_clock(GET_TIME), for_, temp2));
}
else if (!strncmp(line, "Possible bot ", 13))
{
client_bot++;
if (!(flags & POSSIBLE_BOT))
goto done;
p = line + 13;
for_ = next_arg(p, &p);
if ((temp2 = next_arg(p, &p)))
chop(temp2, 1);
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_BOT_FSET), "%s %s %s", update_clock(GET_TIME), for_, temp2));
}
else if (wild_match("Possible % bot *", line))
{
char *possible = NULL;
client_bot++;
if (!(flags & POSSIBLE_BOT))
goto done;
p = line;
possible = next_arg(p, &p);
next_arg(p, &p);
for_ = next_arg(p, &p);
if ((temp2 = next_arg(p, &p)))
{
chop(temp2, 1);
*temp2 = ' ';
}
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_BOT1_FSET), "%s %s %s %s", update_clock(GET_TIME), possible?possible:"Unknown", for_, temp2));
}
else if (wild_match("% % is now operator*", line))
{
oper_requests++;
if (!(flags & OPER_MODE))
goto done;
p = line;
fr = next_arg(p, &p);
if ((temp2 = next_arg(p, &p)))
{
chop(temp2, 1);
if (*temp2 == '(')
*temp2 = ' ';
}
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_OPER_FSET), "%s %s %s", update_clock(GET_TIME), fr, temp2));
}
else if (!strncmp(line, "Received SQUIT", 14))
{
serv_squits++;
if (!(flags & SQUIT))
goto done;
p = line + 14;
fr = next_arg(p, &p);
p += 5;
for_ = next_arg(p, &temp2);
if (temp2)
{
chop(temp2, 1);
if (*temp2 == '(')
temp2++;
}
serversay(1, from_server, "%s", convert_output_format(" SQUIT of $1 from $2 %K[%R$3-%K]", "%s %s %s %s", update_clock(GET_TIME), for_, fr, temp2));
}
else if (!strncmp(line, "Received SERVER", 15))
{
serv_squits++;
if (!(flags & SERVER_CONNECT))
goto done;
p = line + 15;
fr = next_arg(p, &p);
p += 5;
for_ = next_arg(p, &temp2);
if (temp2)
{
chop(temp2, 1);
if (*temp2 == '(')
temp2++;
}
serversay(1, from_server, "%s", convert_output_format(" Received SERVER %c$1%n from %c$2%n %K[%W$3-%K]", "%s %s %s %s", update_clock(GET_TIME), fr, for_, temp2));
}
else if (!strncmp(line, "Sending SQUIT", 13))
{
serv_squits++;
if (!(flags & SQUIT)) goto done;
p = line + 13;
fr = next_arg(p, &temp2);
if (temp2)
{
chop(temp2, 1);
if (*temp2 == '(') temp2++;
}
serversay(1, from_server, "%s", convert_output_format(" Sending SQUIT %c$1%n %K[%R$2-%K]", "%s %s %s", update_clock(GET_TIME), fr, temp2));
}
else if (!strncmp(line, "Sending SERVER", 14))
{
serv_squits++;
if (!(flags & SERVER_CONNECT)) goto done;
p = line + 14;
fr = next_arg(p, &temp2);
if (temp2)
{
chop(temp2, 1);
if (*temp2 == '(') temp2++;
}
serversay(1, from_server, "%s", convert_output_format(" Sending SERVER %c$1%n %K[%W$2-%K]", "%s %s %s", update_clock(GET_TIME), fr, temp2));
}
else if (!strncmp(line, "WALLOPS :Remote CONNECT", 23))
{
serv_connects++;
if (!(flags & SERVER_CONNECT))
goto done;
p = line + 23;
for_ = next_arg(p, &p);
fr = next_arg(p, &p);
next_arg(p, &temp2);
serversay(1, from_server, "%s", convert_output_format(" Remote Connect of $1:$2 from $3", "%s %s %s %s", update_clock(GET_TIME), for_, fr, temp2));
}
else if (!strncmp(line, "Client connecting", 17) || !strncmp(line, "Client exiting", 14))
{
char *q = strchr(line, ':');
char *port = empty_string;
int conn = !strncmp(line+7, "connect", 7) ? 1 : 0;
int dalnet = 0, ircnet = 0;
if (strlen(line) >= 19 && line[18] == ':')
q = NULL;
else
dalnet = (q == NULL);
if (!dalnet)
{
if ((q = strchr(q + 1, ' ')))
{
q++;
if (conn)
ircnet = !strcmp(q, "is ");
else
ircnet = !strcmp(q, "was ");
}
}
if (conn)
client_connects++;
else
client_exits++;
if (!(flags & CLIENT_CONNECT))
goto done;
p = line;
next_arg(p, &p); next_arg(p, &p);
if (ircnet)
{
for_ = LOCAL_COPY(p);
fr = LOCAL_COPY(p);
temp = LOCAL_COPY(p);
temp2 = LOCAL_COPY(p);
if (conn) sscanf(p, "%s is %s from %s", for_, fr, temp);
else sscanf(p, "%s was %s from %s", for_, fr, temp);
q = p;
sprintf(q, "%s@%s", fr, temp);
if (!conn)
{
port = strstr(temp2, "reason:");
port += 8;
}
}
else if (dalnet && !conn)
{
for_ = next_arg(p, &p);
q = temp2 = p;
if (temp2)
{
chop(temp2, 1);
q = temp2+1;
}
}
else if (conn && dalnet)
{
next_arg(p, &p); next_arg(p, &p);
port = next_arg(p, &p);
if (!(for_ = next_arg(p, &p)))
for_ = port;
{
q = temp2 = p;
chop(port, 1);
if (temp2)
{
chop(temp2, 1);
q = temp2+1;
}
}
}
else /* hybrid */
{
for_ = q;
if ((q = strchr(q, ' ')))
{
*q = 0;
q += 2;
}
if ((port = strchr(q, ' ')))
{
*port = 0;
port++;
chop(q, 1);
}
}
serversay(1, from_server, "%s", convert_output_format(fget_string_var(conn ? FORMAT_SERVER_NOTICE_CLIENT_CONNECT_FSET : FORMAT_SERVER_NOTICE_CLIENT_EXIT_FSET), "%s %s %s %s", update_clock(GET_TIME), for_, q ? q : empty_string, port ? port : empty_string));
}
else if (!strncmp(line, "Terminating client for excess", 29))
{
char *q;
client_floods++;
if (!(flags & TERM_FLOOD))
goto done;
p = line + 29;
for_ = next_arg(p, &p);
q = temp2 = p;
if (temp2)
{
chop(temp2, 1);
q = temp2+1;
}
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_CLIENT_TERM_FSET), "%s %s %s", update_clock(GET_TIME), for_, q));
}
else if (!strncmp(line, "Invalid username:"******"%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_CLIENT_INVALID_FSET), "%s %s %s", update_clock(GET_TIME), for_, temp2));
}
else if (!strncmp(line, "STATS ", 6))
{
stats_req++;
if (!(flags & STATS_REQUEST))
goto done;
p = line + 6;
temp = next_arg(p, &p);
p += 12;
for_ = next_arg(p, &p);
if ( (temp2 = ++p) )
chop(temp2, 1);
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_STATS_FSET), "%s %s %s %s", update_clock(GET_TIME), temp, for_, temp2));
}
else if (!strncmp(line, "Nick flooding detected by:", 26))
{
if (!(flags & NICK_FLOODING))
goto done;
p = line + 26;
serversay(1, from_server, "%s", convert_output_format(" Nick Flooding %K[%B$1-%K]", "%s %s", update_clock(GET_TIME), for_));
}
else if (!strncmp(line, "Kill line active for", 20) || !strncmp(line+14, "K-line active for", 17))
{
if (!(flags & KILL_ACTIVE))
goto done;
if (!strncmp(line + 14,"Kill", 4))
for_ = line + 20;
else
for_ = line + 17;
serversay(1, from_server, "%s", convert_output_format(" Kill line for $1 active", "%s %s", update_clock(GET_TIME), for_));
}
else
{
if (!(flags & SERVER_CRAP))
goto done;
serversay(1, from_server, "%s", convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_FSET), "%s %s %s", update_clock(GET_TIME), from, stripansicodes(line)));
add_last_type(&last_servermsg[0], MAX_LAST_MSG, NULL, NULL, NULL, line);
}
done:
reset_display_target();
return done_one;
}
/*
* do_notice_ctcp: a re-entrant form of a CTCP reply parser.
* See the implementation notes in do_ctcp().
*/
char * do_notice_ctcp (const char *from, const char *to, char *str)
{
int flag;
char local_ctcp_buffer [BIG_BUFFER_SIZE + 1],
the_ctcp [IRCD_BUFFER_SIZE + 1],
last [IRCD_BUFFER_SIZE + 1];
char *ctcp_command,
*ctcp_argument;
int i;
char *ptr;
int allow_ctcp_reply = 1;
int l;
int delim_char = charcount(str, CTCP_DELIM_CHAR);
if (delim_char < 2)
return str; /* No CTCPs. */
if (delim_char > 8)
allow_ctcp_reply = 0; /* Ignore all the CTCPs. */
/* We handle ignore, but not flooding (obviously) */
flag = check_ignore_channel(from, FromUserHost, to, LEVEL_CTCP);
in_ctcp_flag++;
strlcpy(local_ctcp_buffer, str, sizeof(local_ctcp_buffer) - 2);
for (;;strlcat(local_ctcp_buffer, last, sizeof(local_ctcp_buffer) - 2))
{
if (split_CTCP(local_ctcp_buffer, the_ctcp, last))
break; /* All done! */
if (!*the_ctcp)
continue; /* Empty requests are ignored */
/*
* The logic of all this is essentially the same as
* do_ctcp
*/
if (!allow_ctcp_reply)
continue;
if (flag == IGNORED)
{
if (x_debug & DEBUG_CTCPS)
yell("CTCP REPLY from [%s] ignored", from);
allow_ctcp_reply = 0;
continue;
}
/* But we don't check ctcp flooding (obviously) */
/* Global messages -- just drop the CTCP */
if (*to == '$' || (is_channel(to) &&
!im_on_channel(to, from_server)))
{
allow_ctcp_reply = 0;
continue;
}
/*
* Parse CTCP message
* CTCP spec says word delim MUST be space
*/
ctcp_command = the_ctcp;
ctcp_argument = strchr(the_ctcp, ' ');
if (ctcp_argument)
*ctcp_argument++ = 0;
else
ctcp_argument = endstr(the_ctcp);
/* Set up the window level/logging */
if (is_channel(to))
l = message_from(to, LEVEL_CTCP);
else
l = message_from(from, LEVEL_CTCP);
/*
* Find the correct CTCP and run it.
*/
for (i = 0; i < NUMBER_OF_CTCPS; i++)
if (!strcmp(ctcp_command, ctcp_cmd[i].name))
break;
/*
* If its a built in CTCP command, check to see if its
* got a reply handler, call if appropriate.
*/
if (i < NUMBER_OF_CTCPS && ctcp_cmd[i].repl)
{
if ((ptr = ctcp_cmd[i].repl(ctcp_cmd + i, from, to,
ctcp_argument)))
{
strlcat(local_ctcp_buffer, ptr,
sizeof local_ctcp_buffer);
new_free(&ptr);
pop_message_from(l);
continue;
}
}
/* Toss it at the user. */
if (ctcp_cmd[i].flag & CTCP_TELLUSER)
{
if (do_hook(CTCP_REPLY_LIST, "%s %s %s %s",
from, to, ctcp_command, ctcp_argument))
say("CTCP %s reply from %s: %s",
ctcp_command, from, ctcp_argument);
}
if (!(ctcp_cmd[i].flag & CTCP_NOLIMIT))
allow_ctcp_reply = 0;
pop_message_from(l);
}
in_ctcp_flag--;
/*
* local_ctcp_buffer is derived from 'str', so its always
* smaller or equal in size to 'str', so this copy is safe.
*/
strlcpy(str, local_ctcp_buffer, BIG_BUFFER_SIZE);
return str;
}
/*
* do_ctcp: a re-entrant form of a CTCP parser. The old one was lame,
* so i took a hatchet to it so it didnt suck.
*
* XXXX - important! The third argument -- 'str', is expected to be
* 'BIG_BUFFER_SIZE + 1' or larger. If it isnt, chaos will probably
* ensue if you get spammed with lots of CTCP UTC requests.
*
* UTC requests can be at minimum 5 bytes, and the expansion is always 24.
* That means you can cram (510 - strlen("PRIVMSG x :") / 5) UTCs (100)
* into a privmsg. That means itll expand to 2400 characters. We silently
* limit the number of valid CTCPs to 4. Anything more than that we dont
* even bother with. (4 * 24 + 11 -> 106), which is less than
* IRCD_BUFFER_SIZE, which gives us plenty of safety.
*
* XXXX - The normal way of implementation required two copies -- once into a
* temporary buffer, once back into the original buffer -- for the best case
* scenario. This is horrendously inefficient, since most privmsgs dont
* contain any CTCPs. So we check to see if there are any CTCPs in the
* message before we bother doing anything. THIS IS AN INELEGANT HACK!
* But the call to charcount() is less expensive than even one copy to
* strlcpy() since they both evaluate *each* character, and charcount()
* doesnt have to do a write unless the character is present. So it is
* definitely worth the cost to save CPU time for 99% of the PRIVMSGs.
*/
char * do_ctcp (const char *from, const char *to, char *str)
{
int flag;
int fflag;
char local_ctcp_buffer [BIG_BUFFER_SIZE + 1],
the_ctcp [IRCD_BUFFER_SIZE + 1],
last [IRCD_BUFFER_SIZE + 1];
char *ctcp_command,
*ctcp_argument;
int i;
char *ptr = NULL;
int allow_ctcp_reply = 1;
static time_t last_ctcp_parsed = 0;
int l;
char * extra = NULL;
int delim_char = charcount(str, CTCP_DELIM_CHAR);
if (delim_char < 2)
return str; /* No CTCPs. */
if (delim_char > 8)
allow_ctcp_reply = 0; /* Historical limit of 4 CTCPs */
flag = check_ignore_channel(from, FromUserHost, to, LEVEL_CTCP);
fflag = new_check_flooding(from, FromUserHost, is_channel(to) ? to : NULL,
str, LEVEL_CTCP);
in_ctcp_flag++;
strlcpy(local_ctcp_buffer, str, sizeof(local_ctcp_buffer) - 2);
for (;;strlcat(local_ctcp_buffer, last, sizeof(local_ctcp_buffer) - 2))
{
if (split_CTCP(local_ctcp_buffer, the_ctcp, last))
break; /* All done! */
if (!*the_ctcp)
continue; /* Empty requests are ignored */
/*
* Apply some integrety rules:
* -- If we've already replied to a CTCP, ignore it.
* -- If user is ignoring sender, ignore it.
* -- If we're being flooded, ignore it.
* -- If CTCP was a global msg, ignore it.
*/
/*
* Yes, this intentionally ignores "unlimited" CTCPs like
* UTC and SED. Ultimately, we have to make sure that
* CTCP expansions dont overrun any buffers that might
* contain this string down the road. So by allowing up to
* 4 CTCPs, we know we cant overflow -- but if we have more
* than 40, it might overflow, and its probably a spam, so
* no need to shed tears over ignoring them. Also makes
* the sanity checking much simpler.
*/
if (!allow_ctcp_reply)
continue;
/*
* Check to see if the user is ignoring person.
* Or if we're suppressing a flood.
*/
if (flag == IGNORED || fflag == 1)
{
if (x_debug & DEBUG_CTCPS)
yell("CTCP from [%s] ignored", from);
allow_ctcp_reply = 0;
continue;
}
/*
* Check for CTCP flooding
*/
if (get_int_var(NO_CTCP_FLOOD_VAR))
{
if (time(NULL) - last_ctcp_parsed < 2)
{
/*
* This extends the flood protection until
* we dont get a CTCP for 2 seconds.
*/
last_ctcp_parsed = time(NULL);
allow_ctcp_reply = 0;
if (x_debug & DEBUG_CTCPS)
say("CTCP flood from [%s] ignored", from);
continue;
}
}
/*
* Check for global message
*/
if (*to == '$' || (*to == '#' && !im_on_channel(to, from_server)))
{
allow_ctcp_reply = 0;
continue;
}
/*
* Now its ok to parse the CTCP.
* First we remove the argument.
* XXX - CTCP spec says word delim MUST be space.
*/
ctcp_command = the_ctcp;
ctcp_argument = strchr(the_ctcp, ' ');
if (ctcp_argument)
*ctcp_argument++ = 0;
else
ctcp_argument = endstr(the_ctcp);
/* Set up the window level/logging */
if (im_on_channel(to, from_server))
l = message_from(to, LEVEL_CTCP);
else
l = message_from(from, LEVEL_CTCP);
/*
* Then we look for the correct CTCP.
*/
for (i = 0; i < NUMBER_OF_CTCPS; i++)
if (!strcmp(ctcp_command, ctcp_cmd[i].name))
break;
/*
* We didnt find it?
*/
if (i == NUMBER_OF_CTCPS)
{
/*
* Offer it to the user.
* Maybe they know what to do with it.
*/
if (do_hook(CTCP_REQUEST_LIST, "%s %s %s %s",
from, to, ctcp_command, ctcp_argument))
{
if (do_hook(CTCP_LIST, "%s %s %s %s", from, to,
ctcp_command, ctcp_argument))
{
say("Unknown CTCP %s from %s to %s: %s%s",
ctcp_command, from, to,
*ctcp_argument ? ": " : empty_string,
ctcp_argument);
}
}
time(&last_ctcp_parsed);
allow_ctcp_reply = 0;
pop_message_from(l);
continue;
}
/*
* rfc1459_any_to_utf8 specifically ignores CTCPs, because
* recoding binary data (such as an encrypted message) would
* corrupt the message.
*
* So some CTCPs are "recodable" and some are not.
*
* The CTCP_NORECODE is set for any CTCPs which are NOT
* to be recoded prior to handling. These are the encryption
* CTCPS.
*
* All other CTCPs have not been recoded by the time they
* reach here, so we must do it here!
*/
if (!(ctcp_cmd[i].flag & CTCP_NORECODE))
{
/*
* We must recode to UTF8
*/
inbound_recode(from, from_server, to, ctcp_argument, &extra);
if (extra)
ctcp_argument = extra;
}
/*
* We did find it. Acknowledge it.
*/
ptr = NULL;
if (do_hook(CTCP_REQUEST_LIST, "%s %s %s %s",
from, to, ctcp_command, ctcp_argument))
{
ptr = ctcp_cmd[i].func(ctcp_cmd + i, from,
to, ctcp_argument);
}
/*
* If this isnt an 'unlimited' CTCP, set up flood protection.
*
* No, this wont allow users to flood any more than they
* would normally. The UTC/SED gets converted into a
* regular privmsg body, which is flagged via FLOOD_PUBLIC.
*/
if (!(ctcp_cmd[i].flag & CTCP_NOLIMIT))
{
time(&last_ctcp_parsed);
allow_ctcp_reply = 0;
}
/*
* We've only gotten to this point if its a valid CTCP
* query and we decided to parse it.
*/
/*
* If its an ``INLINE'' CTCP, we paste it back in.
*/
if (ctcp_cmd[i].flag & CTCP_INLINE)
strlcat(local_ctcp_buffer, ptr ? ptr : empty_string, sizeof local_ctcp_buffer);
/*
* If its ``INTERESTING'', tell the user.
* Note that this isnt mutex with ``INLINE'' in theory,
* even though it is in practice. Dont use 'else' here.
*/
if (ctcp_cmd[i].flag & CTCP_TELLUSER)
{
if (do_hook(CTCP_LIST, "%s %s %s %s",
from, to, ctcp_command, ctcp_argument))
{
if (is_me(from_server, to))
say("CTCP %s from %s%s%s",
ctcp_command, from,
*ctcp_argument ? ": " : empty_string,
ctcp_argument);
else
say("CTCP %s from %s to %s%s%s",
ctcp_command, from, to,
*ctcp_argument ? ": " : empty_string,
ctcp_argument);
}
}
new_free(&extra);
new_free(&ptr);
pop_message_from(l);
}
in_ctcp_flag--;
/*
* 'str' is required to be BIG_BUFFER_SIZE + 1 or bigger per the API.
*/
strlcpy(str, local_ctcp_buffer, BIG_BUFFER_SIZE);
return str;
}
/*
* find the paths where info files are to be found,
* and put them in the global var infopaths[]
*/
void
initpaths()
{
char emptystr[1] = "";
char **paths = NULL;
char *infopath = NULL, *langpath = NULL;
char *c, *dir, *env, *next;
char *rawlang = NULL, *lang = NULL, *langshort = NULL;
int ret;
unsigned int i, j, maxpaths, numpaths = 0, infolen, langlen;
size_t len;
struct stat sbuf;
ino_t *inodes;
/* first concat the paths */
env = getenv("INFOPATH");
if (env == NULL)
{
env = emptystr;
}
infolen = strlen(env) + strlen(configuredinfopath) + 3;
infopath = (char *) xmalloc( infolen );
strcat(infopath, env);
strcat(infopath, ":");
strcat(infopath, configuredinfopath);
/* end with a :, otherwise the strchr below will fail for the last entry */
strcat(infopath, ":");
/* alloc the paths[] array */
maxpaths = 3 * (charcount( infopath, ':' ) + 1); // *3 for $LANG
paths = (char **) xmalloc( maxpaths * sizeof(char *) );
/* split at ':' and put the path components into paths[] */
dir = infopath;
/* if this actually is a non-empty string, add it to paths[] */
while ( (next = strchr(dir, ':')) != NULL )
{
*next = '\0'; /* terminate the string */
/* if the dir actually is a non-empty string, add it to paths[] */
if ( dir && strlen(dir)>0 )
{
paths[numpaths++] = dir;
}
/* and advance the pointer to the next entry */
dir = next+1;
}
/* get the current $LANG, if any (to use for localized info pages) */
rawlang = getenv("LANG");
if (rawlang) {
lang = strdup(rawlang);
/* fix the lang string */
for (i=0; lang[i]!='\0'; i++)
{
/* cut off the charset */
if (lang[i]=='.')
{
lang[i]='\0';
}
/* if lang is sublocalized (nl_BE or so), also use short version */
if (lang[i]=='_' && langshort==NULL)
{
langshort = strdup(lang);
langshort[i] = '\0';
}
}
}
/* if we have a LANG defined, add paths with this lang to the paths[] */
if (lang && strlen(lang)>0 )
{
/* crude upper limit */
langlen = infolen + (strlen(lang)+2) * numpaths + 1;
if (langshort!=NULL) langlen *= 2;
langpath = (char *) xmalloc( langlen * sizeof(char) );
c = langpath;
for (i=0; i<numpaths; i++)
{
/* TODO: check for negative return values of sprintf */
len = sprintf(c, "%s/%s", paths[i], lang);
/* add the lang specific dir at the beginning */
paths[numpaths+i] = paths[i];
paths[i] = c;
c += len+1;
if (langshort)
{
/* TODO: check for negative return values of sprintf */
len = sprintf(c, "%s/%s", paths[numpaths+i], langshort);
/* add the lang specific dir at the beginning */
paths[2*numpaths+i] = paths[numpaths+i];
paths[numpaths+i] = c;
c += len+1;
}
}
numpaths *= (langshort?3:2);
}
#ifdef ___DEBUG___
/* for debugging */
for (i=0; i<numpaths; i++)
fprintf(stderr,"--> %s\n", paths[i]);
#endif
/* ok, now we have all the (possibly) revelevant paths in paths[] */
/* now loop over them, see if they are valid and if they are duplicates*/
/* TODO: cleanup all malloc calls (get rid of cast, use sizeof(varname) instead of sizeof(type) */
inodes = (ino_t *) xmalloc( maxpaths * sizeof(ino_t) );
numpaths = 0;
len = 0;
for (i=0; i< maxpaths; i++)
{
/* TODO: check where these NULL paths come from */
if (paths[i]==NULL)
continue;
/* stat() the dir */
ret = stat( paths[i], &sbuf);
/* and see if it could be opened */
if (ret < 0)
{
#ifdef ___DEBUG___
fprintf(stderr, "error while opening `%s': %s\n",
paths[i], strerror(errno) );
#endif
paths[i] = NULL;
inodes[i] = 0;
}
else
{
inodes[i] = sbuf.st_ino;
}
/* now check if this path is a duplicate */
for (j=0; j<i; j++)
{
if (inodes[j]==inodes[i]) paths[i] = NULL;
}
/* calculate the total number of vali paths and the size of teh strings */
if (paths[i]!=NULL)
{
numpaths++;
len += strlen(paths[i]) + 1;
}
}
/* and alloc and copy to global var */
infopathcount = numpaths;
infopaths = (char **) xmalloc( numpaths * sizeof(char *) );
c = (char *) xmalloc( len * sizeof(char) );
j=0;
for (i=0; i<maxpaths; i++)
{
if (paths[i]!=NULL)
{
/* copy path to c buffer */
strcpy(c, paths[i]);
infopaths[j++] = c;
c += strlen(paths[i]) + 1;
}
}
xfree(infopath);
xfree(langpath);
xfree(paths);
xfree(lang);
xfree(langshort);
xfree(inodes);
#ifdef ___DEBUG___
/* for debugging */
fprintf(stderr, "%i valid info paths found:\n", infopathcount);
for (i=0; i<infopathcount; i++)
if (infopaths[i]) fprintf(stderr,"--> %s\n", infopaths[i]);
#endif
}
/*
* do_notice_ctcp: a re-entrant form of a CTCP reply parser.
* See the implementation notes in do_ctcp().
*/
char * do_notice_ctcp (const char *from, const char *to, char *str)
{
int flag;
int lastlog_level;
char local_ctcp_buffer [BIG_BUFFER_SIZE + 1],
the_ctcp [IRCD_BUFFER_SIZE + 1],
last [IRCD_BUFFER_SIZE + 1];
char *ctcp_command,
*ctcp_argument;
int i;
char *ptr;
int allow_ctcp_reply = 1;
int delim_char = charcount(str, CTCP_DELIM_CHAR);
if (delim_char < 2)
return str; /* No CTCPs. */
if (delim_char > 8)
allow_ctcp_reply = 0; /* Ignore all the CTCPs. */
flag = check_ignore_channel(from, FromUserHost, to, IGNORE_CTCPS);
if (!in_ctcp_flag)
in_ctcp_flag = -1;
strlcpy(local_ctcp_buffer, str, IRCD_BUFFER_SIZE - 2);
for (;;strlcat(local_ctcp_buffer, last, sizeof local_ctcp_buffer))
{
if (split_CTCP(local_ctcp_buffer, the_ctcp, last))
break; /* All done! */
if (!*the_ctcp)
continue; /* Empty requests are ignored */
/*
* Apply sanity rules
*/
if (!allow_ctcp_reply)
continue;
if (flag == IGNORED)
{
if (x_debug & DEBUG_CTCPS)
yell("CTCP REPLY from [%s] ignored", from);
allow_ctcp_reply = 0;
continue;
}
/* Global messages -- just drop the CTCP */
if (*to == '$' || (*to == '#' && !im_on_channel(to, from_server)))
{
allow_ctcp_reply = 0;
continue;
}
/*
* Parse CTCP message
* CTCP spec says word delim MUST be space.
*/
ctcp_command = the_ctcp;
ctcp_argument = strchr(the_ctcp, ' ');
if (ctcp_argument)
*ctcp_argument++ = 0;
else
ctcp_argument = empty_string;
/*
* Find the correct CTCP and run it.
*/
for (i = 0; i < NUMBER_OF_CTCPS; i++)
if (!strcmp(ctcp_command, ctcp_cmd[i].name))
break;
/*
* If its a built in CTCP command, check to see if its
* got a reply handler, call if appropriate.
*/
if (i < NUMBER_OF_CTCPS && ctcp_cmd[i].repl)
{
if ((ptr = ctcp_cmd[i].repl(ctcp_cmd + i, from, to, ctcp_argument)))
{
strlcat(local_ctcp_buffer, ptr, sizeof local_ctcp_buffer);
new_free(&ptr);
continue;
}
}
/* Set up the window level/logging */
lastlog_level = set_lastlog_msg_level(LOG_CTCP);
message_from(NULL, LOG_CTCP);
/* Toss it at the user. */
if (do_hook(CTCP_REPLY_LIST, "%s %s %s %s", from, to, ctcp_command, ctcp_argument))
say("CTCP %s reply from %s: %s", ctcp_command, from, ctcp_argument);
/* Reset the window level/logging */
set_lastlog_msg_level(lastlog_level);
if (!(ctcp_cmd[i].flag & CTCP_NOLIMIT))
allow_ctcp_reply = 0;
}
if (in_ctcp_flag == -1)
in_ctcp_flag = 0;
/*
* local_ctcp_buffer is derived from 'str', so its always
* smaller or equal in size to 'str', so this copy is safe.
*/
strlcpy(str, local_ctcp_buffer, BIG_BUFFER_SIZE);
return str;
}
