/* addrout -- Translate address 'a' from int to text. */ const char * addrout(long a, int prt, int myprt) { static char buf[128]; char tmpbuf[128]; const char *ptr, *ptr2; struct in_addr addr; struct hostent *he; addr.s_addr = a; ptr = hostfetch(ntohl(a)); if (ptr) { ptr2 = get_username(a, prt, myprt); if (ptr2) { sprintf(buf, "%s(%s)", ptr, ptr2); } else { sprintf(buf, "%s(%d)", ptr, prt); } return buf; } he = gethostbyaddr(((char *)&addr), sizeof(addr), AF_INET); if (he) { strcpy(tmpbuf, he->h_name); hostadd(ntohl(a), tmpbuf); ptr = get_username(a, prt, myprt); if (ptr) { sprintf(buf, "%s(%s)", tmpbuf, ptr); } else { sprintf(buf, "%s(%d)", tmpbuf, prt); } return buf; } a = ntohl(a); sprintf(tmpbuf, "%ld.%ld.%ld.%ld", (a >> 24) & 0xff, (a >> 16) & 0xff, (a >> 8) & 0xff, a & 0xff ); hostadd_timestamp(a, tmpbuf); ptr = get_username(htonl(a), prt, myprt); if (ptr) { sprintf(buf, "%s(%s)", tmpbuf, ptr); } else { sprintf(buf, "%s(%d)", tmpbuf, prt); } return buf; }
void send_priv(char * str) { if (is_logged()) { int username_length; if ((username_length = get_username(str)) != FAIL) { chatmsg_data.type = MESSAGE; strcpy(chatmsg_data.receiver, str); strcpy(chatmsg_data.sender, username); strcpy(chatmsg_data.message, &str[username_length+1]); if (chatmsg_data.message[0]) { get_time(chatmsg_data.send_time); chatmsg_data.msg_type = PRIVATE; if (send_message(chatmsg_data.type, &chatmsg_data) != FAIL && wait_until_received(RESPONSE) != FAIL) { if (response_data.response_type == MSG_SEND) { print_msg(0); } else { writestr("message wasn't sent"); } } } else { writestr("No use in sending empty message."); } } else { writestr("This priv doesn't make sense."); } } else { writestr("To perform this, you have to be logged in."); } }
UsernameToken::UsernameToken(SOAPEnvelope& soap, const std::string& username, const std::string& uid, bool mac, int iteration) { header_=soap.Header(); uid_ = uid; iteration_ = iteration; //Get the username username_=username; if(username_.empty()) get_username(username_); salt_ = get_salt(mac); // Apply predefined namespace prefix NS ns; ns["wsse"]=WSSE_NAMESPACE; ns["wsse11"]=WSSE11_NAMESPACE; ns["wsu"]=WSU_NAMESPACE; header_.Namespaces(ns); //Check the arguments if(username_.empty() || salt_.empty()) { std::cerr<<"Username and Salt should not be empty"<<std::endl; header_=XMLNode(); return; } // Insert the related elements XMLNode wsse = get_node(header_,"wsse:Security"); XMLNode ut = get_node(wsse, "wsse:UsernameToken"); if(!uid_.empty()) { ut.NewAttribute("wsse:Id") = uid_; } get_node(ut, "wsse:Username") = username_; get_node(ut, "wsse11:Salt") = salt_; get_node(ut, "wsse11:Iteration") = tostring(iteration); }
int main(int argv, char **argc) { char *user_name; user_name = get_username(argc[1]); printf("User name is '%s'\n",user_name); return 0; }
void build_ustar_header_from_file(FILE_HEADER* header, char* filename) { struct stat buffer; errno = 0; if(stat(filename, &buffer) == 0 && errno == 0) { clean_up_header(header); get_prefix_and_name(filename, header->name, header->prefix); get_file_mode(header->mode, buffer.st_mode); get_id(header->uid, buffer.st_uid); get_id(header->gid, buffer.st_gid); get_size(header->size, buffer.st_size); get_modification_time(header->mtime, buffer.st_mtime); get_file_type(header->typeflag, buffer.st_mode); strcpy(header->magic, "ustar "); strcpy(header->version, " \0"); get_username(header->uname, buffer.st_uid); get_groupname(header->gname, buffer.st_gid); get_device_numbers(header->devmajor, header->devminor, buffer.st_dev); calculate_checksum(header); } else fprintf(stderr, "%s '%s': %s\n", STAT_FAILURE_ERR, filename, strerror(errno)); }
static void format(FTSENT *cur, FTSENT_PRT *prt) { char buf[NAME_BUFSZ]; cur->fts_pointer=prt; if (f_inodenum) UP(buf, "%llu", (LLU)cur->fts_statp->st_ino, prt->s_inode); /** * st_blocks is a calculated number of blocks via file system block size * the value is the same with that displayed when using default ls * it can also be calculated via: * howmany(st_blocks, blocksize) e.g. st_blocks/blocksize */ if (f_longfmt || f_dispblock) { LL b=(LL)cur->fts_statp->st_blocks; b/=block_size_factor; UP(buf, "%lld", b, prt->s_block); prt->t_block+=b; } if (f_longfmt) { mode_t m=cur->fts_statp->st_mode; if (f_kilobytes) { LLU s=cur->fts_statp->st_size; UP(buf, "%llu", (LLU)(s/1024.0+0.5), prt->s_float); } else if (f_readable) { LLU s=cur->fts_statp->st_size; char *read=readable(s); prt->s_read=MAX(prt->s_read, strlen(read)); free(read); } else { UP(buf, "%llu", (LLU)cur->fts_statp->st_size, prt->s_size); } UP(buf, "%hu", (short)cur->fts_statp->st_nlink, prt->s_link); if (S_ISCHR(m) || S_ISBLK(m)) { UP(buf, "%d", major(cur->fts_statp->st_rdev), prt->s_major); UP(buf, "%d", minor(cur->fts_statp->st_rdev), prt->s_minor); } } if (f_numric) { UP(buf, "%d", cur->fts_statp->st_uid, prt->s_uid); UP(buf, "%d", cur->fts_statp->st_gid, prt->s_gid); } else if (f_longfmt) { char *username=get_username(cur->fts_statp->st_uid); char *groupname=get_groupname(cur->fts_statp->st_uid); if (username!=NULL) UP(buf, "%s", username, prt->s_uname); if (groupname!=NULL) UP(buf, "%s", groupname, prt->s_gname); free(username); free(groupname); } UP(buf, "%s", cur->fts_name, prt->s_name); prt->col_length=MAX(prt->col_length, prt->s_name); prt->entries++; }
static void default_env(){ rrdpath = strdup(DATA_DIR); struct passwd* passwd = getpwnam(drop_username); struct group* group = getgrnam(drop_group); if ( passwd ){ drop_uid = passwd->pw_uid; } else { fprintf(stderr, "%s: no such user `%s': defaulting to current user\n", program_name, drop_username); drop_uid = getuid(); drop_username = get_username(drop_uid); } if ( group ){ drop_gid = group->gr_gid; } else { fprintf(stderr, "%s: no such group `%s': defaulting to current primary group\n", program_name, drop_group); drop_gid = getgid(); drop_group = get_groupname(drop_gid); } /* set database username to current user */ struct passwd* user = getpwuid(getuid()); if ( user ){ strncpy(db_username, user->pw_name, sizeof(db_username)); db_username[sizeof(db_username)-1] = '\0'; } else { fprintf(stderr, "%s: failed to get current user\n", program_name); } if ( strcmp(program_name, "MArelayD") == 0 ){ have_relay_daemon = true; } else { have_control_daemon = true; } }
void test_client_session::on_packet( iod_packet* packet ) { if (test_helper::check_cmd(packet, SESSION_CMD_LOGIN)) { send_command(SESSION_CMD_LOGIN_RES, get_username()); } if (test_helper::check_cmd(packet, SESSION_CMD_INFO)) { char info[1024]; int data_length = packet->get_length(); int cmd_length = (int)strlen(SESSION_CMD_INFO); if (data_length - cmd_length >= sizeof(info)) { memcpy(info, packet->get_data() + cmd_length, sizeof(info) - 1); info[sizeof(info) - 1] = 0; } else { memcpy(info, packet->get_data() + cmd_length, data_length - cmd_length); info[data_length - cmd_length] = 0; } //iod_log_info("user %s, receive info: %s", username, info); if ((rand() % 200) == 1) { send_command(SESSION_CMD_INFO, "test info response"); } } else if (test_helper::check_cmd(packet, SESSION_CMD_LOGOUT)) { //iod_log_info("user %s, logout", get_username()); close(0); } else if (test_helper::check_cmd(packet, SESSION_CMD_LOGIN_RES)) { //iod_log_info("user %s, login sucess", get_username()); login_stat = LOGIN_STATE_LOGINED; } }
static void setupsys() { char *ptr; /* get host name */ gethostname(HostName,sizeof(HostName)); HostPid = getpid(); /* get user's login name */ get_username(UserName,sizeof(UserName)); /* get system name */ ptr = getenv("vnmrsystem"); if (ptr) { if ( strlen(ptr) < MAXPATHL - 32) strcpy(systemdir,ptr); else { fprintf(stderr,"Error:value of environment variable 'vnmrsystem' too long\n"); exit(1); } } else /* use default */ { #ifdef VMS strcpy(systemdir,"[vnmr]"); #else strcpy(systemdir,"/vnmr"); #endif } setupBlocking(); }
int main(int argc, char *argv[]) { const char *line, *user, *host; /* Device line name. */ if ((line = ptsname(STDIN_FILENO)) == NULL) return (EX_USAGE); if ((argc == 2 || argc == 3) && strcmp(argv[1], "login") == 0) { /* Username. */ user = get_username(); if (user == NULL) return (EX_OSERR); /* Hostname. */ host = argc == 3 ? argv[2] : NULL; ulog_login(line, user, host); return (EX_OK); } else if (argc == 2 && strcmp(argv[1], "logout") == 0) { ulog_logout(line); return (EX_OK); } return (EX_USAGE); }
Url * url_init(Url *u, char *string) { char *sp; /* since we're going to walk through string, use a copy instead. */ sp = string; u->full_url = (char *)strdup(string); if( ! (sp = get_service_type(sp, u)) ) return 0; /* only get username/password if they are not null, allows us to handle redirects properly */ if( !u->username ) sp = get_username(sp, u); if( !u->password ) sp = get_password(sp, u); sp = get_hostname(sp, u); if( ! (u->host && *(u->host)) ) return NULL; sp = get_port(sp, u); sp = get_path(sp, u); sp = get_file(sp, u); return u; }
static int process_request(request_rec* r) { char message[MESSAGE_LEN]; sprintf(message, "Starting Tractis auth module process for url %s\n", r->uri); log_debug(message); char *enabled = is_enabled(r); //Not enabled if (enabled == NULL || strcmp(enabled,"true") !=0) { char buff[MESSAGE_LEN]; sprintf(buff,"Module not enabled for given url"); log_debug(buff); return DECLINED; } else { char buff[MESSAGE_LEN]; sprintf(buff,"Module enabled for given url"); log_debug(buff); } //Recover credentials char *user = get_username(r); char *password = get_password(r); char *api_key = get_api_key(r); if (is_debug_enabled()) { char debug_message[MESSAGE_LEN]; sprintf(debug_message, "Credentials are %s:%s and api key is %s", user,password,api_key); log_debug(debug_message); } char* certificate = (char*)apr_table_get(r->subprocess_env, "SSL_CLIENT_CERT"); //The certificate is not present so the client is not allowed to use the service if (!certificate) { char error_message[MESSAGE_LEN]; log_error(401, "No certificate has been provided"); return 401; //HTTP unauthorized } else { if (is_debug_enabled()) { char message[MESSAGE_LEN + strlen(certificate)]; sprintf(message, "User provided certificate \n->%s<-",certificate); log_debug(message); } } int certificate_status = validate_certificate(r,certificate, user, password, api_key); if (certificate_status == VALID) return OK; else { if(is_info_enabled()) { char validation_result[MESSAGE_LEN]; sprintf(validation_result, "The provided certificate reported unsuccessful validation, result code is %d", certificate_status); log_info(validation_result); } //Non valid auth return 401; } }
UsernameToken::UsernameToken(SOAPEnvelope& soap, const std::string& username, const std::string& password,const std::string& uid, PasswordType pwdtype) { header_=soap.Header(); uid_ = uid; iteration_ = 0; //Get the username username_=username; if(username_.empty()) get_username(username_); //Get the password password_=password; if(password_.empty()) get_password(password_,false); // Apply predefined namespace prefix NS ns; ns["wsse"]=WSSE_NAMESPACE; ns["wsse11"]=WSSE11_NAMESPACE; ns["wsu"]=WSU_NAMESPACE; header_.Namespaces(ns); //Check the arguments if(username_.empty() || password_.empty()) { std::cerr<<"Username and Password should not be empty"<<std::endl; header_=XMLNode(); return; } // Insert the related elements XMLNode wsse = get_node(header_,"wsse:Security"); XMLNode ut = get_node(wsse, "wsse:UsernameToken"); if(!uid_.empty()) { ut.NewAttribute("wsu:Id") = uid_; } get_node(ut, "wsse:Username") = username_; XMLNode passwd_node = get_node(ut, "wsse:Password"); if(pwdtype == PasswordText) { passwd_node.NewAttribute("Type") = passwdtype_ = PASSWORD_TEXT; passwd_node = password_; } else if(pwdtype == PasswordDigest) { passwd_node.NewAttribute("Type") = passwdtype_ = PASSWORD_DIGEST; nonce_ = get_nonce(); get_node(ut, "wsse:Nonce") = nonce_; created_ = Time().str(UTCTime); get_node(ut, "wsu:Created") = created_; //std::cout<<"nonce: "<<nonce_<<"createdtime: "<<created_<<"password: "******"Unsupported password type requested"<<std::endl; header_=XMLNode(); return; } }
/* Get username and password login information from the entry boxes */ static void get_login(GtkWidget *entry) { TRACE(stdout, "%s", "Getting login text..."); get_username(); get_password(); gtk_main_quit(); TRACE(stdout, "%s", "Done getting login text."); }
void Application::calaosServerDetected() { if (get_applicationStatus() != Common::NotConnected) return; loadSettings(); login(get_username(), get_password(), get_hostname()); }
/* * Default settings that are specific to pterm. */ char *platform_default_s(const char *name) { if (!strcmp(name, "TermType")) return dupstr(getenv("TERM")); if (!strcmp(name, "UserName")) return get_username(); return NULL; }
int fill_entry_struct(struct Entry *entry, const struct Rc *rc, const struct Options *opt) { unsigned int i; assert(entry); assert(rc); assert(opt); /* * Get information about the environment; hostname, current directory, * login name and tty. * * Fixme: Add check so this and the session info thing are run only * once. Only has some effect if creating many UUIDs. */ entry->host = get_hostname(rc); if (!entry->host) { myerror("fill_entry_struct(): Cannot get hostname"); return EXIT_FAILURE; } if (!valid_hostname(entry->host)) { myerror("fill_entry_struct(): Got invalid hostname: \"%s\"", entry->host); return EXIT_FAILURE; } entry->cwd = getpath(); entry->user = get_username(); entry->tty = get_tty(); /* * Store tags and comment in entry. */ for (i = 0; i < MAX_TAGS && opt->tag[i]; i++) if (store_tag(entry, opt->tag[i]) == EXIT_FAILURE) return EXIT_FAILURE; if (opt->comment) { entry->txt = process_comment_option(opt->comment); if (!entry->txt) return EXIT_FAILURE; } /* * Store session information from the environment variable. */ if (get_sess_info(entry) == EXIT_FAILURE) { free(entry->txt); return EXIT_FAILURE; } return EXIT_SUCCESS; }
static svn_error_t * svn_ra_local__lock(svn_ra_session_t *session, apr_hash_t *path_revs, const char *comment, svn_boolean_t force, svn_ra_lock_callback_t lock_func, void *lock_baton, apr_pool_t *pool) { svn_ra_local__session_baton_t *sess = session->priv; apr_hash_index_t *hi; apr_pool_t *iterpool = svn_pool_create(pool); /* A username is absolutely required to lock a path. */ SVN_ERR(get_username(session, pool)); for (hi = apr_hash_first(pool, path_revs); hi; hi = apr_hash_next(hi)) { svn_lock_t *lock; const void *key; const char *path; void *val; svn_revnum_t *revnum; const char *abs_path; svn_error_t *err, *callback_err = NULL; svn_pool_clear(iterpool); apr_hash_this(hi, &key, NULL, &val); path = key; revnum = val; abs_path = svn_path_join(sess->fs_path->data, path, iterpool); /* This wrapper will call pre- and post-lock hooks. */ err = svn_repos_fs_lock(&lock, sess->repos, abs_path, NULL, comment, FALSE /* not DAV comment */, 0 /* no expiration */, *revnum, force, iterpool); if (err && !SVN_ERR_IS_LOCK_ERROR(err)) return err; if (lock_func) callback_err = lock_func(lock_baton, path, TRUE, err ? NULL : lock, err, iterpool); svn_error_clear(err); if (callback_err) return callback_err; } svn_pool_destroy(iterpool); return SVN_NO_ERROR; }
int sspi_logout(const struct protocol_interface *protocol) { const char *user = get_username(current_server()->current_root); if(sspi_set_user_password(user,current_server()->current_root->hostname,current_server()->current_root->port,current_server()->current_root->directory,NULL)) { server_error(1,"Failed to delete password"); } return CVSPROTO_SUCCESS; }
static char *make_name(const char *prefix, const char *name) { char *username, *retname; username = get_username(); retname = dupprintf("%s.%s.%s", prefix, username, name); sfree(username); return retname; }
static svn_error_t * svn_ra_local__unlock(svn_ra_session_t *session, apr_hash_t *path_tokens, svn_boolean_t force, svn_ra_lock_callback_t lock_func, void *lock_baton, apr_pool_t *pool) { svn_ra_local__session_baton_t *sess = session->priv; apr_hash_index_t *hi; apr_pool_t *iterpool = svn_pool_create(pool); /* A username is absolutely required to unlock a path. */ SVN_ERR(get_username(session, pool)); for (hi = apr_hash_first(pool, path_tokens); hi; hi = apr_hash_next(hi)) { const void *key; const char *path; void *val; const char *abs_path, *token; svn_error_t *err, *callback_err = NULL; svn_pool_clear(iterpool); apr_hash_this(hi, &key, NULL, &val); path = key; /* Since we can't store NULL values in a hash, we turn "" to NULL here. */ if (strcmp(val, "") != 0) token = val; else token = NULL; abs_path = svn_path_join(sess->fs_path->data, path, iterpool); /* This wrapper will call pre- and post-unlock hooks. */ err = svn_repos_fs_unlock(sess->repos, abs_path, token, force, iterpool); if (err && !SVN_ERR_IS_UNLOCK_ERROR(err)) return err; if (lock_func) callback_err = lock_func(lock_baton, path, FALSE, NULL, err, iterpool); svn_error_clear(err); if (callback_err) return callback_err; } svn_pool_destroy(iterpool); return SVN_NO_ERROR; }
static char *make_parentdir_name(void) { char *username, *parent; username = get_username(); parent = dupprintf("%s.%s", CONNSHARE_SOCKETDIR_PREFIX, username); sfree(username); assert(*parent == '/'); return parent; }
static int printuname(FTSENT *p, int length) { char *username=get_username(p->fts_statp->st_uid); if (username!=NULL) { printf("%-*s ", length, username); free(username); return 0; } return -1; }
/* Arguements: None Returns (void) */ void print_prompt() { char *hostname = get_hostname(); char *username = get_username(); char *cwd = get_cwd(); printf("%s@%s:%s$ ", username, hostname, cwd); free(hostname); free(username); free(cwd); }
int pgut_getopt(int argc, char **argv, pgut_option options[]) { int c; int optindex = 0; char *optstring; struct option *longopts; pgut_option *opt; if (PROGRAM_NAME == NULL) { PROGRAM_NAME = get_progname(argv[0]); set_pglocale_pgservice(argv[0], "pgscripts"); } /* Help message and version are handled at first. */ if (argc > 1) { if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0) { help(true); exit_or_abort(HELP); } if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0) { fprintf(stderr, "%s %s\n", PROGRAM_NAME, PROGRAM_VERSION); exit_or_abort(HELP); } } /* Merge default and user options. */ longopts = option_merge(default_options, options); optstring = longopts_to_optstring(longopts); /* Assign named options */ while ((c = getopt_long(argc, argv, optstring, longopts, &optindex)) != -1) { opt = option_find(c, default_options, options); assign_option(opt, optarg, SOURCE_CMDLINE); } /* Read environment variables */ option_from_env(options); (void) (dbname || (dbname = getenv("PGDATABASE")) || (dbname = getenv("PGUSER")) || (dbname = get_username())); init_cancel_handler(); atexit(on_cleanup); return optind; }
char *get_remote_username(Conf *conf) { char *username = conf_get_str(conf, CONF_username); if (*username) { return dupstr(username); } else if (conf_get_int(conf, CONF_username_from_env)) { /* Use local username. */ return get_username(); /* might still be NULL */ } else { return NULL; } }
int sspi_login(const struct protocol_interface *protocol, char *password) { CScramble scramble; const char *user = get_username(current_server()->current_root); /* Store username & encrypted password in password store */ if(sspi_set_user_password(user,current_server()->current_root->hostname,current_server()->current_root->port,current_server()->current_root->directory,scramble.Scramble(password))) { server_error(1,"Failed to store password"); } return CVSPROTO_SUCCESS; }
void readline_print_status() { char str_prompt[STR_SIZE]; #if 0 term_puts("myshell"); term_putc(get_prompt()); term_putc(' '); #endif sprintf(str_prompt, "%s@%s:%s%c ", get_username(), get_nodename(), get_current_short_dir(), get_prompt()); term_puts(str_prompt); }
static svn_error_t * svn_ra_local__change_rev_prop(svn_ra_session_t *session, svn_revnum_t rev, const char *name, const svn_string_t *value, apr_pool_t *pool) { svn_ra_local__session_baton_t *sess = session->priv; SVN_ERR(get_username(session, pool)); return svn_repos_fs_change_rev_prop3(sess->repos, rev, sess->username, name, value, TRUE, TRUE, NULL, NULL, pool); }
int pgut_getopt(int argc, char **argv, pgut_option options[]) { int c; int optindex = 0; char *optstring; struct option *longopts; pgut_option *opt; pgut_init(argc, argv); /* Help message and version are handled at first. */ if (argc > 1) { if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0) { help(true); exit(1); } if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0) { printf("%s %s\n", PROGRAM_NAME, PROGRAM_VERSION); exit(1); } if (strcmp(argv[1], "--configuration") == 0) { printf("%s\n", PG_VERSION_STR); exit(0); } } /* Merge default and user options. */ longopts = option_merge(default_options, options); optstring = longopts_to_optstring(longopts); /* Assign named options */ while ((c = getopt_long(argc, argv, optstring, longopts, &optindex)) != -1) { opt = option_find(c, default_options, options); pgut_setopt(opt, optarg, SOURCE_CMDLINE); } /* Read environment variables */ option_from_env(options); (void) (dbname || (dbname = getenv("PGDATABASE")) || (dbname = getenv("PGUSER")) || (dbname = get_username())); return optind; }