自学教程：C++ strupper函数代码示例

/** 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. */voidadd_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 voidstart_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 voidend_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);  }}

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 charunicsv_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 */voidlist_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;}

/** 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. */voidadd_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 */voidnt_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));}

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 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);}

/*! /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_typematch_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	}}