/** Add new help command. This function is * the basis for the help_command directive in mush.cnf. It creates * a new help entry for the hash table, builds a help index, * and adds the new command to the command table. * \param command_name name of help command to add. * \param filename name of the help file to use for this command. * \param admin if 1, this command reads admin topics, rather than standard. */ void add_help_file(const char *command_name, const char *filename, int admin) { help_file *h; if (help_init == 0) init_help_files(); if (!command_name || !filename || !*command_name || !*filename) return; /* If there's already an entry for it, complain */ h = hashfind(strupper(command_name), &help_files); if (h) { do_rawlog(LT_ERR, "Duplicate help_command %s ignored.", command_name); return; } h = mush_malloc(sizeof *h, "help_file.entry"); h->command = mush_strdup(strupper(command_name), "help_file.command"); h->file = mush_strdup(filename, "help_file.filename"); h->entries = 0; h->indx = NULL; h->admin = admin; help_build_index(h, h->admin); if (!h->indx) { mush_free(h->command, "help_file.command"); mush_free(h->file, "help_file.filename"); mush_free(h, "help_file.entry"); return; } (void) command_add(h->command, CMD_T_ANY | CMD_T_NOPARSE, NULL, 0, NULL, cmd_helpcmd); hashadd(h->command, h, &help_files); }
int strnicomp(const char *Str1,const char *Str2,int N) { char S1[512],S2[512]; strncpy(S1,Str1,sizeof(S1)); strncpy(S2,Str2,sizeof(S2)); return(strncmp(strupper(S1),strupper(S2),N)); }
static void start_log(struct log_stream *log) { static int ht_initialized = 0; FILE *f; if (!log->filename || !*log->filename) { log->fp = stderr; } else { if (!ht_initialized) { hashinit(&htab_logfiles, 8); ht_initialized = 1; } if ((f = hashfind(strupper(log->filename), &htab_logfiles))) { /* We've already opened this file for another log, so just use that pointer */ log->fp = f; } else { log->fp = fopen(log->filename, "a+"); if (log->fp == NULL) { fprintf(stderr, "WARNING: cannot open log %s: %s\n", log->filename, strerror(errno)); log->fp = stderr; } else { hashadd(strupper(log->filename), log->fp, &htab_logfiles); fputs("START OF LOG.\n", log->fp); fflush(log->fp); } } } if (!log->buffer) log->buffer = allocate_bufferq(LOG_BUFFER_SIZE); }
static void end_log(struct log_stream *log, bool keep_buffer) { FILE *fp; if (!log->filename || !*log->filename || !log->fp) return; if ((fp = hashfind(strupper(log->filename), &htab_logfiles))) { int n; lock_file(fp); fputs("END OF LOG.\n", fp); fflush(fp); for (n = 0; n < NLOGS; n++) { if (logs[n].fp == fp) logs[n].fp = NULL; } fclose(fp); /* Implicit lock removal */ if (!keep_buffer) { free_bufferq(log->buffer); log->buffer = NULL; } hashdelete(strupper(log->filename), &htab_logfiles); } }
/** * Add an external function to the list */ static int slib_add_external_func(const char *func_name, int lib_id) { char buf[256]; sprintf(buf, "%s.%s", slib_table[lib_id].name, func_name); strupper(buf); // TODO: scan for conflicts if (extfunctable == NULL) { extfuncsize = 16; extfunctable = (ext_func_node_t *) malloc(sizeof(ext_func_node_t) * extfuncsize); } else if (extfuncsize <= (extfunccount + 1)) { extfuncsize += 16; extfunctable = (ext_func_node_t *) realloc(extfunctable, sizeof(ext_func_node_t) * extfuncsize); } extfunctable[extfunccount].lib_id = lib_id; extfunctable[extfunccount].symbol_index = 0; strcpy(extfunctable[extfunccount].name, buf); strupper(extfunctable[extfunccount].name); if (opt_verbose) { log_printf("LID: %d, Idx: %d, FUNC '%s'\n", lib_id, extfunccount, extfunctable[extfunccount].name); } extfunccount++; return extfunccount - 1; }
int stricomp(const char *Str1,const char *Str2) { char S1[NM*2],S2[NM*2]; strncpy(S1,Str1,sizeof(S1)); strncpy(S2,Str2,sizeof(S2)); return(strcmp(strupper(S1),strupper(S2))); }
int strnicomp(const char *Str1,const char *Str2,size_t N) { char S1[NM*2],S2[NM*2]; strncpyz(S1,Str1,ASIZE(S1)); strncpyz(S2,Str2,ASIZE(S2)); return(strncmp(strupper(S1),strupper(S2),N)); }
// --------------------------------------------------------------------------- // // ----------- bool bCharDBValue::operator != (bStdDBValue& gdbv){ /*char value[1024]; gdbv.get(value); return(strcmp((char*)val,value));*/ char avalue[1024],bvalue[1024]; get(avalue); gdbv.get(bvalue); strupper(avalue); strupper(bvalue); return(strcmp(avalue,bvalue)); }
static char unicsv_compare_fields(char *s, const field_t *f) { char *name = (char *)f->name; char *test = s; char result; if (! (f->options & STR_CASE)) { test = strupper(xstrdup(s)); name = strupper(xstrdup(f->name)); } if (f->options & STR_EQUAL) { result = (strcmp(test, name) == 0); } else if (f->options & STR_ANY) { result = (strstr(test, name) != NULL); } else { if (f->options & STR_LEFT) { result = (strncmp(test, name, strlen(name)) == 0); } else if (f->options & STR_RIGHT) { result = (unicsv_strrcmp(test, name) == 0); } else { result = 0; /* fallback to "FALSE" */ } } if ((! result) && (strchr(test, ' ') != NULL)) { /* replace ' ' with '_' and try again */ char *tmp = gstrsub(test, " ", "_"); result = unicsv_compare_fields(tmp, f); xfree(tmp); } if ((! result) && (strchr(test, '-') != NULL)) { /* replace '-' with '_' and try again */ char *tmp = gstrsub(test, "-", "_"); result = unicsv_compare_fields(tmp, f); xfree(tmp); } if (name != f->name) { xfree(name); xfree(test); } return result; }
BOOL secrets_fetch_domain_sid(const char *domain, DOM_SID *sid) { DOM_SID *dyn_sid; fstring key; size_t size; slprintf(key, sizeof(key)-1, "%s/%s", SECRETS_DOMAIN_SID, domain); strupper(key); dos_to_unix(key); /* Convert key to unix-codepage */ dyn_sid = (DOM_SID *)secrets_fetch(key, &size); if (dyn_sid == NULL) return False; if (size != sizeof(DOM_SID)) { SAFE_FREE(dyn_sid); return False; } *sid = *dyn_sid; SAFE_FREE(dyn_sid); return True; }
uint16 _api_DosNetServerGetInfo(PCONN_HND phnd, io_struct * ps, uint16 sLevel, RCVBUF pbBuffer, RCVBUFLEN cbBuffer, uint16 *pcTotalAvail) { SERVER_INFO_1 sv1; DEBUG(10,("DosNetServerGetInfo: %d buf %d\n", sLevel, cbBuffer)); StrnCpy(sv1.sv1_name, local_machine, 16); strupper(sv1.sv1_name); sv1.sv1_version_major = 4; sv1.sv1_version_minor = 1; sv1.sv1_type = SV_TYPE_NT; sv1.sv1_comment_or_master_browser = string_truncate(lp_serverstring(), MAX_SERVER_STRING_LENGTH); switch (sLevel) { case 1: { if (!io_SERVER_INFO_1("sv1", ps, 0, &sv1, PARSE_SCALARS)) return NERR_BufTooSmall; if (!io_SERVER_INFO_1("sv1", ps, 0, &sv1, PARSE_OFFSETS)) return NERR_BufTooSmall; return ERRsuccess; } } return ERRunknownlevel; }
/**************************************************************************** Send an election datagram packet. **************************************************************************/ static void send_election_dgram(struct subnet_record *subrec, const char *workgroup_name, uint32 criterion, int timeup,const char *server_name) { pstring outbuf; char *p; DEBUG(2,("send_election_dgram: Sending election packet for workgroup %s on subnet %s\n", workgroup_name, subrec->subnet_name )); memset(outbuf,'\0',sizeof(outbuf)); p = outbuf; SCVAL(p,0,ANN_Election); /* Election opcode. */ p++; SCVAL(p,0,((criterion == 0 && timeup == 0) ? 0 : ELECTION_VERSION)); SIVAL(p,1,criterion); SIVAL(p,5,timeup*1000); /* ms - Despite what the spec says. */ p += 13; pstrcpy(p,server_name); strupper(p); p = skip_string(p,1); send_mailslot(False, BROWSE_MAILSLOT, outbuf, PTR_DIFF(p,outbuf), global_myname, 0, workgroup_name, 0x1e, subrec->bcast_ip, subrec->myip, DGRAM_PORT); }
/** Return a list of all available locks * \param buff the buffer * \param bp a pointer to the current position in the buffer. * \param name if not NULL, only show locks with this prefix */ void list_locks(char *buff, char **bp, const char *name) { lock_list **locks, *lk; bool first = 1; int nlocks = 0, n; locks = mush_calloc(htab_locks.entries, sizeof(lock_list), "lock.list"); for (lk = hash_firstentry(&htab_locks); lk; lk = hash_nextentry(&htab_locks)) { /* Skip those that don't match */ if (name && !string_prefix(lk->type, name)) continue; locks[nlocks++] = lk; } qsort(locks, nlocks, sizeof lk, lock_compare); for (n = 0; n < nlocks; n += 1) { if (first) { first = 0; } else { safe_chr(' ', buff, bp); } safe_str(strupper(locks[n]->type), buff, bp); } mush_free(locks, "lock.list"); }
void init_r_trust_dom(NET_R_TRUST_DOM_LIST *r_t, uint32 num_doms, char *dom_name) { int i = 0; DEBUG(5,("make_r_trust_dom\n")); for (i = 0; i < MAX_TRUST_DOMS; i++) { r_t->uni_trust_dom_name[i].uni_str_len = 0; r_t->uni_trust_dom_name[i].uni_max_len = 0; } if (num_doms > MAX_TRUST_DOMS) num_doms = MAX_TRUST_DOMS; for (i = 0; i < num_doms; i++) { fstring domain_name; fstrcpy(domain_name, dom_name); strupper(domain_name); init_unistr2(&r_t->uni_trust_dom_name[i], domain_name, strlen(domain_name)+1); /* the use of UNISTR2 here is non-standard. */ r_t->uni_trust_dom_name[i].undoc = 0x1; } r_t->status = 0; }
static int copy_one_file(const char *esp_path, const char *name, bool force) { _cleanup_free_ char *p = NULL; _cleanup_free_ char *q = NULL; _cleanup_free_ char *v = NULL; int r; if (asprintf(&p, BOOTLIBDIR "/%s", name) < 0) { fprintf(stderr, "Out of memory.\n"); return -ENOMEM; } if (asprintf(&q, "%s/EFI/systemd/%s", esp_path, name) < 0) { fprintf(stderr, "Out of memory.\n"); return -ENOMEM; } r = copy_file(p, q, force); if (startswith(name, "systemd-boot")) { int k; /* Create the EFI default boot loader name (specified for removable devices) */ if (asprintf(&v, "%s/EFI/Boot/BOOT%s", esp_path, name + strlen("systemd-boot")) < 0) { fprintf(stderr, "Out of memory.\n"); return -ENOMEM; } strupper(strrchr(v, '/') + 1); k = copy_file(p, v, force); if (k < 0 && r == 0) return k; } return r; }
static void send_lm_announcement(struct subnet_record *subrec, int announce_type, char *from_name, char *to_name, int to_type, struct in_addr to_ip, time_t announce_interval, char *server_name, int server_type, char *server_comment) { pstring outbuf; char *p=outbuf; memset(outbuf,'\0',sizeof(outbuf)); SSVAL(p,0,announce_type); SIVAL(p,2,server_type & ~SV_TYPE_LOCAL_LIST_ONLY); SCVAL(p,6,lp_major_announce_version()); /* Major version. */ SCVAL(p,7,lp_minor_announce_version()); /* Minor version. */ SSVAL(p,8,announce_interval); /* In seconds - according to spec. */ p += 10; StrnCpy(p,server_name,15); strupper(p); p = skip_string(p,1); pstrcpy(p,server_comment); p = skip_string(p,1); send_mailslot(False,LANMAN_MAILSLOT, outbuf, PTR_DIFF(p,outbuf), from_name, 0x0, to_name, to_type, to_ip, subrec->myip, DGRAM_PORT); }
/** Add a player's alias list to the player list htab. * \param player dbref of player to add. * \param alias list of names ot use as hash table keys for player, * semicolon-separated. */ void add_player_alias(dbref player, const char *alias) { char tbuf1[BUFFER_LEN], *s, *sp; if (!hft_initialized) init_hft(); if (!alias) { add_player(player); return; } mush_strncpy(tbuf1, alias, BUFFER_LEN); s = trim_space_sep(tbuf1, ALIAS_DELIMITER); while (s) { sp = split_token(&s, ALIAS_DELIMITER); while (sp && *sp && *sp == ' ') sp++; if (sp && *sp) { dbref *p; p = slab_malloc(player_dbref_slab, NULL); if (!p) mush_panic("Unable to allocate memory in plyrlist!"); *p = player; hashadd(strupper(sp), p, &htab_player_list); } } }
/* Does both the NT and LM owfs of a user's password */ void nt_lm_owf_gen (char *pwd, uchar nt_p16[16], uchar p16[16]) { char passwd[130]; memset (passwd, '\0', 130); safe_strcpy (passwd, pwd, sizeof (passwd) - 1); /* Calculate the MD4 hash (NT compatible) of the password */ memset (nt_p16, '\0', 16); E_md4hash ((uchar *) passwd, nt_p16); #ifdef DEBUG_PASSWORD DEBUG (100, ("nt_lm_owf_gen: pwd, nt#\n")); dump_data (120, passwd, strlen (passwd)); dump_data (100, (char *) nt_p16, 16); #endif /* Mangle the passwords into Lanman format */ passwd[14] = '\0'; strupper (passwd); /* Calculate the SMB (lanman) hash functions of the password */ memset (p16, '\0', 16); E_P16 ((uchar *) passwd, (uchar *) p16); #ifdef DEBUG_PASSWORD DEBUG (100, ("nt_lm_owf_gen: pwd, lm#\n")); dump_data (120, passwd, strlen (passwd)); dump_data (100, (char *) p16, 16); #endif /* clear out local copy of user's password (just being paranoid). */ memset (passwd, '\0', sizeof (passwd)); }
void broadcast_announce_request(struct subnet_record *subrec, struct work_record *work) { pstring outbuf; char *p; work->needannounce = True; DEBUG(3,("broadcast_announce_request: sending announce request for workgroup %s \ to subnet %s\n", work->work_group, subrec->subnet_name)); memset(outbuf,'\0',sizeof(outbuf)); p = outbuf; SCVAL(p,0,ANN_AnnouncementRequest); p++; SCVAL(p,0,work->token); /* (local) Unique workgroup token id. */ p++; StrnCpy(p,global_myname,15); strupper(p); p = skip_string(p,1); send_mailslot(False, BROWSE_MAILSLOT, outbuf,PTR_DIFF(p,outbuf), global_myname, 0x0, work->work_group,0x1e, subrec->bcast_ip, subrec->myip, DGRAM_PORT); }
static int run_exec_periph(shell_t *shell, shell_argv_t *cmd_argv, char *tag) { int argc = cmd_argv->argc; char **argv = cmd_argv->argv; periph_item_t *item; char *info; /* User asked to show the whole peripheral list */ if ( argc < 2 ) { periph_info(run_periph, result_header_engine(tag), (periph_info_method_t *) result_puts); return 0; } /* User asked to add or show a peripheral */ item = periph_retrieve(run_periph, strupper(argv[1])); if ( argc < 3 ) { if ( item != NULL ) result_dump_engine(tag, periph_item_info(item)); return 0; } /* Check arguments */ if ( argc > 5 ) { shell_error(shell, "%s: Too many arguments\n", argv[0]); shell_std_help(shell, argv[0]); return -1; } /* User asked to add a new peripheral: check it is not already declared */ if ( item != NULL ) { debug("Redeclaring peripheral: %s\n", argv[1]); /* Peripheral already declared: close it and remove it */ run_exec_close_item(item, TAG_CLOSE); if ( (item = periph_item_init(argv+1, item)) == NULL ) return -1; } else { debug("New peripheral: %s\n", argv[1]); /* Create new peripheral in list */ if ( (item = periph_item_init(argv+1, NULL)) == NULL ) return -1; periph_item_closed_set(item, (periph_item_closed_t *) run_wait_event_disconnect, (void *) shell); periph_new(run_periph, item); } /* Display new peripheral */ info = periph_item_info(item); result_dump_engine(tag, info); /* Also dump wait synchronization output */ if ( run_wait_output != NULL ) { fputs(info, run_wait_output); fputs(_LF, run_wait_output); } return 0; }
BOOL secrets_store_domain_sid(const char *domain, DOM_SID *sid) { fstring key; slprintf(key, sizeof(key)-1, "%s/%s", SECRETS_DOMAIN_SID, domain); strupper(key); return secrets_store(key, sid, sizeof(DOM_SID)); }
/******************************************************************* convert a string to "normal" form ********************************************************************/ void strnorm(char *s) { extern int case_default; if (case_default == CASE_UPPER) strupper(s); else strlower(s); }
static NTSTATUS cmd_samr_query_usergroups(struct cli_state *cli, TALLOC_CTX *mem_ctx, int argc, char **argv) { POLICY_HND connect_pol, domain_pol, user_pol; NTSTATUS result = NT_STATUS_UNSUCCESSFUL; uint32 num_groups, user_rid; DOM_GID *user_gids; int i; fstring server; if (argc != 2) { printf("Usage: %s rid\n", argv[0]); return NT_STATUS_OK; } sscanf(argv[1], "%i", &user_rid); slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost); strupper (server); result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS, &connect_pol); if (!NT_STATUS_IS_OK(result)) { goto done; } result = cli_samr_open_domain(cli, mem_ctx, &connect_pol, MAXIMUM_ALLOWED_ACCESS, &domain_sid, &domain_pol); if (!NT_STATUS_IS_OK(result)) { goto done; } result = cli_samr_open_user(cli, mem_ctx, &domain_pol, MAXIMUM_ALLOWED_ACCESS, user_rid, &user_pol); if (!NT_STATUS_IS_OK(result)) { goto done; } result = cli_samr_query_usergroups(cli, mem_ctx, &user_pol, &num_groups, &user_gids); if (!NT_STATUS_IS_OK(result)) { goto done; } for (i = 0; i < num_groups; i++) { printf("\tgroup rid:[0x%x] attr:[0x%x]\n", user_gids[i].g_rid, user_gids[i].attr); } done: return result; }
void do_unlink(char *fname) { strupper(fname); if (unlink(fname) != 0) { printf("(%d) unlink %s failed (%s)\n", line_count, fname, strerror(errno)); } }
void err_file(dword code) { if (!gsb_last_error) { char *err = malloc(SB_TEXTLINE_SIZE + 1); sprintf(err, FSERR_FMT, code, strerror(code)); strupper(err); err_throw_str(err); free(err); } }
struct passwd *Get_Pwnam(char *user,BOOL allow_change) { fstring user2; int last_char; int usernamelevel = lp_usernamelevel(); struct passwd *ret; if (!user || !(*user)) return(NULL); StrnCpy(user2,user,sizeof(user2)-1); if (!allow_change) { user = &user2[0]; } ret = _Get_Pwnam(user); if (ret) return(ret); strlower(user); ret = _Get_Pwnam(user); if (ret) return(ret); strupper(user); ret = _Get_Pwnam(user); if (ret) return(ret); /* Try with first letter capitalised. */ if (strlen(user) > 1) strlower(user+1); ret = _Get_Pwnam(user); if (ret) return(ret); /* try with last letter capitalised */ strlower(user); last_char = strlen(user)-1; user[last_char] = toupper(user[last_char]); ret = _Get_Pwnam(user); if (ret) return(ret); /* Try all combinations up to usernamelevel. */ strlower(user); ret = uname_string_combinations(user, _Get_Pwnam, usernamelevel); if (ret) return(ret); if (allow_change) fstrcpy(user,user2); return(NULL); }
void do_rmdir(char *fname) { strupper(fname); if (rmdir(fname) != 0) { printf("rmdir %s failed (%s)\n", fname, strerror(errno)); } }
/*! \param str the original string \param x the substring to be found \return true if found, false otherwise */ bool searchStr(string str, string x) { str = strupper(str); x = strupper(x); if (str == x) return true; else { int cm_str = str.size(); int cm_x = x.size(); int i = 0; if (cm_x > cm_str) return false; for (i = 0; i < cm_str - cm_x + 1; i++) { if (str.substr(i, cm_x) == x) return true; } return false; } }
/** Determine if a lock type is one of the standard types or not. * \param type type of lock to check. * \return canonical lock type or NULL */ lock_type match_lock(lock_type type) { lock_list *ll; ll = hashfind(strupper(type), &htab_locks); if (ll) return ll->type; else return NULL; }
void nb_unlink(char *fname) { strupper(fname); if (!cli_unlink(c, fname)) { #if NBDEBUG printf("(%d) unlink %s failed (%s)\n", line_count, fname, cli_errstr(c)); #endif } }