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