/** * Handle TIME messages * * @param source is the nick of the person whom requested * @param ac is the parameter count * @param av is the array * * @return always returns MOD_CONT */ int m_time(char *source, int ac, char **av) { time_t t; struct tm tm; char buf[64]; USE_VAR(ac); USE_VAR(av); *buf = '\0'; if (!source) { return MOD_CONT; } time(&t); #ifdef MSVS2005 localtime_s(&tm, &t); #else tm = *localtime(&t); #endif strftime(buf, 63, "%a %b %d %H:%M:%S %Y %Z", &tm); denora_cmd_391(source, buf); return MOD_CONT; }
spif_charptr_t * spiftool_split_regexp(const spif_charptr_t regexp, const spif_charptr_t str) { USE_VAR(regexp); USE_VAR(str); return (NULL); }
void timeout(OPM_T *scanner, OPM_REMOTE_T *remote, int notused, void *data) { USE_VAR(scanner); USE_VAR(notused); USE_VAR(data); printf("Negotiation timed out on %s:%d\n", remote->ip, remote->port); }
void end(OPM_T *scanner, OPM_REMOTE_T *remote, int notused, void *data) { USE_VAR(scanner); USE_VAR(notused); USE_VAR(data); printf("Scan on %s has ended\n", remote->ip); opm_remote_free(remote); complete = 1; }
void negotiation_failed(OPM_T *scanner, OPM_REMOTE_T *remote, int notused, void *data) { USE_VAR(scanner); USE_VAR(notused); USE_VAR(data); printf("Negotiation on %s:%d failed [%d bytes read]\n", remote->ip, remote->port, remote->bytes_read); }
void open_proxy(OPM_T *scanner, OPM_REMOTE_T *remote, int notused, void *data) { USE_VAR(notused); USE_VAR(data); printf("Open proxy on %s:%d [%d bytes read]\n", remote->ip, remote->port, remote->bytes_read); opm_end(scanner, remote); }
/** * Handle VERSION commands * * @param source is the nick of the person whom sent the version command * @param ac is the parameter count * @param av is the parameter array * * @return always returns MOD_CONT */ int m_version(char *source, int ac, char **av) { USE_VAR(ac); USE_VAR(av); if (source) { denora_cmd_351(source); } return MOD_CONT; }
/* * This routine returns the highest address of the segments in the program (NOT * the shared libraries). It is intended to be used as a stop gap for programs * that make UNIX style assumptions about how memory is allocated. Typicly the * asumptions under which this is used is that memory is contiguously allocated * by the program's text and data from address 0 with no gaps. The value of * this differs from the value of &_end in a UNIX program in that this routine * returns the address of the end of the segment not the end of the last section * in that segment as would be the value of the symbol &_end. */ unsigned long get_end(void) { static struct mach_header *mhp = (struct mach_header *)0; struct segment_command *sgp; unsigned long i, _end; #ifndef __OPENSTEP__ if (mhp == (struct mach_header *)0) { mhp = _NSGetMachExecuteHeader(); } #else /* defined(__OPENSTEP__) */ DECLARE_VAR(_mh_execute_header, struct mach_header); SETUP_VAR(_mh_execute_header); mhp = (struct mach_header *)(& USE_VAR(_mh_execute_header)); #endif /* __OPENSTEP__ */ _end = 0; sgp = (struct segment_command *) ((char *)mhp + sizeof(struct mach_header)); for(i = 0; i < mhp->ncmds; i++){ if(sgp->cmd == LC_SEGMENT) if(sgp->vmaddr + sgp->vmsize > _end) _end = sgp->vmaddr + sgp->vmsize; sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize); } return(_end); }
const struct segment_command * getsegbyname( char *segname) { struct segment_command *sgp; uint32_t i; #ifndef RLD #ifndef __OPENSTEP__ struct mach_header *mhp = _NSGetMachExecuteHeader(); #else /* defined(__OPENSTEP__) */ static struct mach_header *mhp = NULL; DECLARE_VAR(_mh_execute_header, struct mach_header); SETUP_VAR(_mh_execute_header); mhp = (struct mach_header *)(& USE_VAR(_mh_execute_header)); #endif /* __OPENSTEP__ */ #else /* defined(RLD) */ mhp = (struct mach_header *)(&_mh_execute_header); #endif /* defined(RLD) */ sgp = (struct segment_command *) ((char *)mhp + sizeof(struct mach_header)); for(i = 0; i < mhp->ncmds; i++){ if(sgp->cmd == LC_SEGMENT) if(strncmp(sgp->segname, segname, sizeof(sgp->segname)) == 0) return(sgp); sgp = (struct segment_command *)((char *)sgp + sgp->cmdsize); } return(NULL); }
void handle_error(OPM_T *scanner, OPM_REMOTE_T *remote, int err, void *data) { USE_VAR(scanner); USE_VAR(data); switch(err) { case OPM_ERR_MAX_READ: printf("Reached MAX READ on %s:%d\n", remote->ip, remote->port); break; case OPM_ERR_BIND: printf("Unable to bind for %s:%d\n", remote->ip, remote->port); break; case OPM_ERR_NOFD: printf("Unable to allocate file descriptor for %s:%d\n", remote->ip, remote->port); break; default: printf("Unknown error on %s:%d, err = %d\n", remote->ip, remote->port, err); } }
const struct section * getsectbyname( const char *segname, const char *sectname) { #ifndef __OPENSTEP__ struct mach_header *mhp = _NSGetMachExecuteHeader(); #else /* defined(__OPENSTEP__) */ static struct mach_header *mhp = NULL; DECLARE_VAR(_mh_execute_header, struct mach_header); SETUP_VAR(_mh_execute_header); mhp = (struct mach_header *)(& USE_VAR(_mh_execute_header)); #endif /* __OPENSTEP__ */ return(getsectbynamefromheader(mhp, segname, sectname)); }
struct mach_header *_NSGetMachExecuteHeader(void) { return(USE_VAR(_mh_execute_header)); }
int *_NSGetArgc(void) { return(USE_VAR(NXArgc)); }
/* Read and execute commands until EOF is reached. This assumes that the input source has already been initialized. */ int reader_loop () { //printf("reader_loop ------> Start\n"); int our_indirection_level; COMMAND * volatile current_command; USE_VAR(current_command); current_command = (COMMAND *)NULL; our_indirection_level = ++indirection_level; while (EOF_Reached == 0) { //printf("EOF_Reached == 0 =======> Start\n"); int code; code = setjmp_nosigs (top_level); #if defined (PROCESS_SUBSTITUTION) unlink_fifo_list (); #endif /* PROCESS_SUBSTITUTION */ /* XXX - why do we set this every time through the loop? */ if (interactive_shell && signal_is_ignored (SIGINT) == 0) { //printf("if (interactive_shell && signal_is_ignored (SIGINT) == 0)\n"); set_signal_handler (SIGINT, sigint_sighandler); } if (code != NOT_JUMPED) { //printf("if (code != NOT_JUMPED)\n"); indirection_level = our_indirection_level; switch (code) { /* Some kind of throw to top_level has occurred. */ case FORCE_EOF: case ERREXIT: case EXITPROG: //printf("case EXITPROG:\n"); current_command = (COMMAND *)NULL; if (exit_immediately_on_error) { //printf("if (exit_immediately_on_error)\n"); variable_context = 0; /* not in a function */ } EOF_Reached = EOF; goto exec_done; case DISCARD: //printf("case DISCARD:\n"); /* Make sure the exit status is reset to a non-zero value, but leave existing non-zero values (e.g., > 128 on signal) alone. */ if (last_command_exit_value == 0) { //printf("if (last_command_exit_value == 0)\n"); last_command_exit_value = EXECUTION_FAILURE; } if (subshell_environment) { //printf("if (subshell_environment)\n"); current_command = (COMMAND *)NULL; EOF_Reached = EOF; goto exec_done; } /* Obstack free command elements, etc. */ if (current_command) { //printf("if (current_command)\n"); dispose_command (current_command); current_command = (COMMAND *)NULL; } #if defined (HAVE_POSIX_SIGNALS) sigprocmask (SIG_SETMASK, &top_level_mask, (sigset_t *)NULL); #endif break; default: command_error ("reader_loop", CMDERR_BADJUMP, code, 0); } } executing = 0; if (temporary_env) { //printf("if (temporary_env)\n"); dispose_used_env_vars (); } #if (defined (ultrix) && defined (mips)) || defined (C_ALLOCA) /* Attempt to reclaim memory allocated with alloca (). */ (void) alloca (0); #endif if (read_command () == 0) { //printf("read_command () == 0\n"); if (interactive_shell == 0 && read_but_dont_execute) { //printf("if (interactive_shell == 0 && read_but_dont_execute)"); last_command_exit_value = EXECUTION_SUCCESS; dispose_command (global_command); global_command = (COMMAND *)NULL; } else if (current_command = global_command) { //printf("else if (current_command:%d = global_command:%d)\n",current_command, global_command); global_command = (COMMAND *)NULL; current_command_number++; executing = 1; stdin_redir = 0; execute_command (current_command); exec_done: QUIT; if (current_command) { //printf("if (current_command)\n"); dispose_command (current_command); current_command = (COMMAND *)NULL; } } } else { /* Parse error, maybe discard rest of stream if not interactive. */ if (interactive == 0) { //printf("if (interactive == 0)\n"); EOF_Reached = EOF; } } if (just_one_command) { //printf("just_one_command\n"); EOF_Reached = EOF; } //printf("EOF_Reached == 0 =======> Exit\n"); } indirection_level--; //printf("reader_loop ------> Exit\n"); return (last_command_exit_value); }