/* measure the length till SEPARATOR, and PEEK that length */
int
botrecv (struct servermsg *msg)
{
int bytes, offset;
char data[MSGBUF];
static unsigned int modes_left = 1;
/* Receive MSGBUF bytes but PEEKing */
bytes = recv (msg->server->sock, data, MSGBUF, MSG_PEEK);
/* The offset till SEPARATOR */
if (strstr (data, SEPARATOR) != NULL)
offset = strstr (data, SEPARATOR) - data + SEPARATOR_LEN;
else
offset = strchr (data, '\0') - data;
data[offset] = '\0';
/* If finished with previous mode changes, check modes for this line */
if (modes_left <= 1)
count_multi (data, &modes_left);
else /* If not, check next */
modes_left--;
/* Really receive, but just one line till SEPARATOR */
if (modes_left <= 1) {
if ((bytes = recv (msg->server->sock, data, offset, 0)) < 1)
return bytes;
/* The separator is kept to mark the end of string */
data[bytes] = '\0';
/* Just in case we got an empty line or NULL */
if (data[0] == '\0')
return bytes;
}
/* If the data received starts with ':' ... */
if (data[0] == ':') /* Most commands: */
parse_server (&data[1], msg, modes_left);
else /* PING, NOTICE, etc. */
parse_server2 (data, msg);
#ifdef DEBUG_VERBOSE
DUMP_MSG (msg);
#endif /* DEBUG */
return bytes;
}
/** Handle received data from a directly connected server.
* @param[in] cptr Peer server that sent us data.
* @param[in] buffer Input buffer.
* @param[in] length Number of bytes in input buffer.
* @return 1 on success or CPTR_KILLED if the client is squit.
*/
int server_dopacket(struct Client* cptr, const char* buffer, int length)
{
const char* src;
char* endp;
char* client_buffer;
assert(0 != cptr);
update_bytes_received(cptr, length);
client_buffer = cli_buffer(cptr);
endp = client_buffer + cli_count(cptr);
src = buffer;
while (length-- > 0) {
*endp = *src++;
/*
* Yuck. Stuck. To make sure we stay backward compatible,
* we must assume that either CR or LF terminates the message
* and not CR-LF. By allowing CR or LF (alone) into the body
* of messages, backward compatibility is lost and major
* problems will arise. - Avalon
*/
if (IsEol(*endp)) {
if (endp == client_buffer)
continue; /* Skip extra LF/CR's */
*endp = '\0';
update_messages_received(cptr);
if (parse_server(cptr, cli_buffer(cptr), endp) == CPTR_KILLED)
return CPTR_KILLED;
/*
* Socket is dead so exit
*/
if (IsDead(cptr))
return exit_client(cptr, cptr, &me, cli_info(cptr));
endp = client_buffer;
}
else if (endp < client_buffer + BUFSIZE)
++endp; /* There is always room for the null */
}
cli_count(cptr) = endp - cli_buffer(cptr);
return 1;
}
static void server_action(int action, struct socket_info *sinfo)
{
if (action == NET_READ) {
if (getline(sinfo) == 1)
parse_server(sinfo);
return;
}
if (action == NET_WRITE) {
if (IsConnecting(sinfo)) {
NotConnecting(sinfo);
SetConnected(sinfo);
NotWriteable(sinfo);
register_to_server(sinfo);
}
return;
}
}
/* :<acct> NET <name> <address> [<nick> [<user> [:<gecos>]]] */
static int db_net(int parc, const char *parv[], void *priv)
{
struct a_network *net;
int line = (int)priv;
if (parc < 3 || parc > 6) {
a_log(LERROR, "Bad NET line on %d", line);
return 0;
}
net = net_create(parv[1]);
if (net == NULL) {
a_log(LERROR, "Failed to allocate network!");
return 0;
}
mowgli_strput(&net->nick, parv[0]);
parse_server(net, parv[2]);
if (parc > 3)
mowgli_strput(&net->nick, parv[3]);
if (parc > 4)
mowgli_strput(&net->ident, parv[4]);
if (parc > 5)
mowgli_strput(&net->gecos, parv[5]);
if (net_add_to_account(net, parv[0]) < 0) {
a_log(LERROR, "Failed to add network %s to account %s", net->name, parv[0]);
goto fail;
}
net_start_connect(net);
return 0;
fail:
net_destroy(net);
return 0;
}
static DBusMessage* dbus_read_servers_ex(DBusMessage *message, int strings)
{
DBusMessageIter iter, array_iter, string_iter;
DBusMessage *error = NULL;
const char *addr_err;
char *dup = NULL;
if (!dbus_message_iter_init(message, &iter))
{
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Failed to initialize dbus message iter");
}
/* check that the message contains an array of arrays */
if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) ||
(dbus_message_iter_get_element_type(&iter) != (strings ? DBUS_TYPE_STRING : DBUS_TYPE_ARRAY)))
{
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
strings ? "Expected array of string" : "Expected array of string arrays");
}
mark_servers(SERV_FROM_DBUS);
/* array_iter points to each "as" element in the outer array */
dbus_message_iter_recurse(&iter, &array_iter);
while (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID)
{
const char *str = NULL;
union mysockaddr addr, source_addr;
int flags = 0;
char interface[IF_NAMESIZE];
char *str_addr, *str_domain = NULL;
if (strings)
{
dbus_message_iter_get_basic(&array_iter, &str);
if (!str || !strlen (str))
{
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Empty string");
break;
}
/* dup the string because it gets modified during parsing */
if (dup)
free(dup);
if (!(dup = str_domain = whine_malloc(strlen(str)+1)))
break;
strcpy(str_domain, str);
/* point to address part of old string for error message */
if ((str_addr = strrchr(str, '/')))
str = str_addr+1;
if ((str_addr = strrchr(str_domain, '/')))
{
if (*str_domain != '/' || str_addr == str_domain)
{
error = dbus_message_new_error_printf(message,
DBUS_ERROR_INVALID_ARGS,
"No domain terminator '%s'",
str);
break;
}
*str_addr++ = 0;
str_domain++;
}
else
{
str_addr = str_domain;
str_domain = NULL;
}
}
else
{
/* check the types of the struct and its elements */
if ((dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY) ||
(dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_STRING))
{
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected inner array of strings");
break;
}
/* string_iter points to each "s" element in the inner array */
dbus_message_iter_recurse(&array_iter, &string_iter);
if (dbus_message_iter_get_arg_type(&string_iter) != DBUS_TYPE_STRING)
{
/* no IP address given */
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected IP address");
break;
}
dbus_message_iter_get_basic(&string_iter, &str);
if (!str || !strlen (str))
{
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Empty IP address");
break;
}
/* dup the string because it gets modified during parsing */
if (dup)
free(dup);
if (!(dup = str_addr = whine_malloc(strlen(str)+1)))
break;
strcpy(str_addr, str);
}
memset(&addr, 0, sizeof(addr));
memset(&source_addr, 0, sizeof(source_addr));
memset(&interface, 0, sizeof(interface));
/* parse the IP address */
if ((addr_err = parse_server(str_addr, &addr, &source_addr, (char *) &interface, &flags)))
{
error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
"Invalid IP address '%s': %s",
str, addr_err);
break;
}
/* 0.0.0.0 for server address == NULL, for Dbus */
if (addr.in.sin_family == AF_INET &&
addr.in.sin_addr.s_addr == 0)
flags |= SERV_NO_ADDR;
if (strings)
{
char *p;
do {
if (str_domain)
{
if ((p = strchr(str_domain, '/')))
*p++ = 0;
}
else
p = NULL;
add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str_domain);
} while ((str_domain = p));
}
else
{
/* jump past the address to the domain list (if any) */
dbus_message_iter_next (&string_iter);
/* parse domains and add each server/domain pair to the list */
do {
str = NULL;
if (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING)
dbus_message_iter_get_basic(&string_iter, &str);
dbus_message_iter_next (&string_iter);
add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str);
} while (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING);
}
/* jump to next element in outer array */
dbus_message_iter_next(&array_iter);
}
cleanup_servers();
if (dup)
free(dup);
return error;
}
int main(int argc, char ** argv)
{
int c;
int flags = MS_MANDLOCK; /* no need to set legacy MS_MGC_VAL */
char * orgoptions = NULL;
char * share_name = NULL;
char * ipaddr = NULL;
char * uuid = NULL;
char * mountpoint = NULL;
char * options;
char * resolved_path;
char * temp;
int rc;
int rsize = 0;
int wsize = 0;
int nomtab = 0;
int uid = 0;
int gid = 0;
int optlen = 0;
int orgoptlen = 0;
int retry = 0; /* set when we have to retry mount with uppercase */
struct stat statbuf;
struct utsname sysinfo;
struct mntent mountent;
FILE * pmntfile;
/* setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE); */
if(argc && argv) {
thisprogram = argv[0];
} else {
mount_cifs_usage();
exit(1);
}
if(thisprogram == NULL)
thisprogram = "mount.cifs";
uname(&sysinfo);
/* BB add workstation name and domain and pass down */
/* #ifdef _GNU_SOURCE
printf(" node: %s machine: %s sysname %s domain %s\n", sysinfo.nodename,sysinfo.machine,sysinfo.sysname,sysinfo.domainname);
#endif */
if(argc > 2) {
share_name = argv[1];
mountpoint = argv[2];
}
/* add sharename in opts string as unc= parm */
while ((c = getopt_long (argc, argv, "afFhilL:no:O:rsSU:vVwt:",
longopts, NULL)) != -1) {
switch (c) {
/* No code to do the following options yet */
/* case 'l':
list_with_volumelabel = 1;
break;
case 'L':
volumelabel = optarg;
break; */
/* case 'a':
++mount_all;
break; */
case '?':
case 'h': /* help */
mount_cifs_usage ();
exit(1);
case 'n':
++nomtab;
break;
case 'b':
flags |= MS_BIND;
break;
case 'm':
flags |= MS_MOVE;
break;
case 'o':
orgoptions = strdup(optarg);
break;
case 'r': /* mount readonly */
flags |= MS_RDONLY;
break;
case 'U':
uuid = optarg;
break;
case 'v':
++verboseflag;
break;
case 'V':
printf ("mount.cifs version: %s.%s%s\n",
MOUNT_CIFS_VERSION_MAJOR,
MOUNT_CIFS_VERSION_MINOR,
MOUNT_CIFS_VENDOR_SUFFIX);
if(mountpassword) {
memset(mountpassword,0,64);
}
exit (0);
case 'w':
flags &= ~MS_RDONLY;
break;
case 'R':
rsize = atoi(optarg) ;
break;
case 'W':
wsize = atoi(optarg);
break;
case '1':
if (isdigit(*optarg)) {
char *ep;
uid = strtoul(optarg, &ep, 10);
if (*ep) {
printf("bad uid value \"%s\"\n", optarg);
exit(1);
}
} else {
struct passwd *pw;
if (!(pw = getpwnam(optarg))) {
printf("bad user name \"%s\"\n", optarg);
exit(1);
}
uid = pw->pw_uid;
endpwent();
}
break;
case '2':
if (isdigit(*optarg)) {
char *ep;
gid = strtoul(optarg, &ep, 10);
if (*ep) {
printf("bad gid value \"%s\"\n", optarg);
exit(1);
}
} else {
struct group *gr;
if (!(gr = getgrnam(optarg))) {
printf("bad user name \"%s\"\n", optarg);
exit(1);
}
gid = gr->gr_gid;
endpwent();
}
break;
case 'u':
got_user = 1;
user_name = optarg;
break;
case 'd':
domain_name = optarg; /* BB fix this - currently ignored */
got_domain = 1;
break;
case 'p':
if(mountpassword == NULL)
mountpassword = calloc(65,1);
if(mountpassword) {
got_password = 1;
strncpy(mountpassword,optarg,64);
}
break;
case 'S':
get_password_from_file(0 /* stdin */,NULL);
break;
case 't':
break;
default:
printf("unknown mount option %c\n",c);
mount_cifs_usage();
exit(1);
}
}
if((argc < 3) || (share_name == NULL) || (mountpoint == NULL)) {
mount_cifs_usage();
exit(1);
}
if (getenv("PASSWD")) {
if(mountpassword == NULL)
mountpassword = calloc(65,1);
if(mountpassword) {
strncpy(mountpassword,getenv("PASSWD"),64);
got_password = 1;
}
} else if (getenv("PASSWD_FD")) {
get_password_from_file(atoi(getenv("PASSWD_FD")),NULL);
} else if (getenv("PASSWD_FILE")) {
get_password_from_file(0, getenv("PASSWD_FILE"));
}
if (orgoptions && parse_options(&orgoptions, &flags))
return -1;
ipaddr = parse_server(&share_name);
if((ipaddr == NULL) && (got_ip == 0)) {
printf("No ip address specified and hostname not found\n");
return -1;
}
/* BB save off path and pop after mount returns? */
resolved_path = malloc(PATH_MAX+1);
if(resolved_path) {
/* Note that if we can not canonicalize the name, we get
another chance to see if it is valid when we chdir to it */
if (realpath(mountpoint, resolved_path)) {
mountpoint = resolved_path;
}
}
if(chdir(mountpoint)) {
printf("mount error: can not change directory into mount target %s\n",mountpoint);
return -1;
}
if(stat (".", &statbuf)) {
printf("mount error: mount point %s does not exist\n",mountpoint);
return -1;
}
if (S_ISDIR(statbuf.st_mode) == 0) {
printf("mount error: mount point %s is not a directory\n",mountpoint);
return -1;
}
if((getuid() != 0) && (geteuid() == 0)) {
if((statbuf.st_uid == getuid()) && (S_IRWXU == (statbuf.st_mode & S_IRWXU))) {
#ifndef CIFS_ALLOW_USR_SUID
/* Do not allow user mounts to control suid flag
for mount unless explicitly built that way */
flags |= MS_NOSUID | MS_NODEV;
#endif
} else {
printf("mount error: permission denied or not superuser and mount.cifs not installed SUID\n");
return -1;
}
}
if(got_user == 0) {
user_name = getusername();
got_user = 1;
}
if(got_password == 0) {
mountpassword = getpass("Password: "******"No server share name specified\n");
printf("\nMounting the DFS root for server not implemented yet\n");
exit(1);
}
if(user_name)
optlen += strlen(user_name) + 6;
if(ipaddr)
optlen += strlen(ipaddr) + 4;
if(mountpassword)
optlen += strlen(mountpassword) + 6;
options = malloc(optlen + 10 + 64 /* space for commas in password */ + 8 /* space for domain= , domain name itself was counted as part of the length username string above */);
if(options == NULL) {
printf("Could not allocate memory for mount options\n");
return -1;
}
options[0] = 0;
strncat(options,"unc=",4);
strcat(options,share_name);
/* scan backwards and reverse direction of slash */
temp = strrchr(options, '/');
if(temp > options + 6)
*temp = '\\';
if(ipaddr) {
strncat(options,",ip=",4);
strcat(options,ipaddr);
}
if(user_name) {
/* check for syntax like user=domain\user */
if(got_domain == 0)
domain_name = check_for_domain(&user_name);
strncat(options,",user="******",domain=",8);
strcat(options,domain_name);
}
}
if(mountpassword) {
/* Commas have to be doubled, or else they will
look like the parameter separator */
/* if(sep is not set)*/
if(retry == 0)
check_for_comma(&mountpassword);
strncat(options,",pass="******",ver=",5);
strcat(options,MOUNT_CIFS_VERSION_MAJOR);
if(orgoptions) {
strcat(options,",");
strcat(options,orgoptions);
}
if(verboseflag)
printf("\nmount.cifs kernel mount options %s \n",options);
if(mount(share_name, mountpoint, "cifs", flags, options)) {
/* remember to kill daemon on error */
char * tmp;
switch (errno) {
case 0:
printf("mount failed but no error number set\n");
break;
case ENODEV:
printf("mount error: cifs filesystem not supported by the system\n");
break;
case ENXIO:
if(retry == 0) {
retry = 1;
tmp = share_name;
while (*tmp && !(((unsigned char)tmp[0]) & 0x80)) {
*tmp = toupper((unsigned char)*tmp);
tmp++;
}
if(!*tmp) {
printf("retrying with upper case share name\n");
goto mount_retry;
}
}
default:
printf("mount error %d = %s\n",errno,strerror(errno));
}
printf("Refer to the mount.cifs(8) manual page (e.g.man mount.cifs)\n");
if(mountpassword) {
memset(mountpassword,0,64);
}
return -1;
} else {
pmntfile = setmntent(MOUNTED, "a+");
if(pmntfile) {
mountent.mnt_fsname = share_name;
mountent.mnt_dir = mountpoint;
mountent.mnt_type = CONST_DISCARD(char *,"cifs");
mountent.mnt_opts = malloc(220);
if(mountent.mnt_opts) {
char * mount_user = getusername();
memset(mountent.mnt_opts,0,200);
if(flags & MS_RDONLY)
strcat(mountent.mnt_opts,"ro");
else
strcat(mountent.mnt_opts,"rw");
if(flags & MS_MANDLOCK)
strcat(mountent.mnt_opts,",mand");
if(flags & MS_NOEXEC)
strcat(mountent.mnt_opts,",noexec");
if(flags & MS_NOSUID)
strcat(mountent.mnt_opts,",nosuid");
if(flags & MS_NODEV)
strcat(mountent.mnt_opts,",nodev");
if(flags & MS_SYNCHRONOUS)
strcat(mountent.mnt_opts,",synch");
if(mount_user) {
if(getuid() != 0) {
strcat(mountent.mnt_opts,",user="******"could not update mount table\n");
}
}
int main(int argc, char* argv[])
{
std::string botname = "harvey";
int sockfd,portno,n;
struct sockaddr_in serv_addr;
struct hostent *server;
int length = 256; // length of the buffer
char buffer[length]; // buffer for reading and writing into the socket
if(argc<3)
{
std::cout<<"Incorrect no. of inputs\n";
exit(0);
}
portno = atoi(argv[1]);
sockfd = socket(AF_INET, SOCK_STREAM, 0); // creating new socket using TCP denoted by SOCK_STREAM
if(sockfd<0)
{
std::cout<<"Error opening the socket\n";
exit(0);
}
server = gethostbyname(argv[2]);
// printf("%s : Server",argv[2]);
// std::cout<<"\n";
if(server == NULL)
{
std::cout<<"No such host\n";
exit(0);
}
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(portno);
serv_addr.sin_addr.s_addr = inet_addr(argv[2]);
memset(buffer,'-', length);
if (connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0)
{
std::cout<<"Error Connecting\n";
}
std::cout<<"Connected\n";
n = write(sockfd,botname.c_str(),strlen(botname.c_str()));
std::cout<<"Botname send\n";
if(n<0)
{
std::cout<<"Error writing to the socket\n";
}
std::unordered_map<std::string,std::string> map_server;
while(true)
{
safety_count += 1;
if (safety_count > SAFETY_MAX_CHATTER)
{
std::cout<<"Too much talking\n";
exit(0);
}
n = read(sockfd,buffer,255);
std::cout<<"Reading from the server\n";
std::cout<<buffer<<"\n";
map_server = parse_server(buffer,strlen(buffer));
std::cout<<"parsing done\n";
take_apt_action(map_server);
// std::string buff_string;
// buff_string = std::string(buffer);
// std::cout<<buff_string<<"\n";
// std::cout<<buffer[0]<<"\n";
}
std::cout<<"Testing Client\n";
return 0;
}
int
main(int argc, char *argv[])
{
int opt, i;
const struct cmdtab *match, *cc, *tab;
#ifndef RESCUE
snmp_client_init(&snmp_client);
snmp_client.trans = SNMP_TRANS_LOC_STREAM;
snmp_client_set_host(&snmp_client, PATH_ILMI_SOCK);
#endif
#ifdef RESCUE
#define OPTSTR "htv"
#else
#define OPTSTR "htvs:"
#endif
while ((opt = getopt(argc, argv, OPTSTR)) != -1)
switch (opt) {
case 'h':
help_func(0, argv);
#ifndef RESCUE
case 's':
parse_server(optarg);
break;
#endif
case 'v':
verbose++;
break;
case 't':
notitle = 1;
break;
}
if (argv[optind] == NULL)
help_func(0, argv);
argc -= optind;
argv += optind;
if ((main_tab = malloc(sizeof(static_main_tab))) == NULL)
err(1, NULL);
memcpy(main_tab, static_main_tab, sizeof(static_main_tab));
#ifndef RESCUE
/* XXX while this is compiled in */
device_register();
#endif
cc = main_tab;
i = 0;
for (;;) {
/*
* Scan the table for a match
*/
tab = cc;
match = NULL;
while (cc->string != NULL) {
if (substr(argv[i], cc->string)) {
if (match != NULL) {
printf("Ambiguous option '%s'",
argv[i]);
cc = tab;
goto subopts;
}
match = cc;
}
cc++;
}
if ((cc = match) == NULL) {
printf("Unknown option '%s'", argv[i]);
cc = tab;
goto subopts;
}
/*
* Have a match. If there is no subtable, there must
* be either a handler or the command is only a help entry.
*/
if (cc->sub == NULL) {
if (cc->func != NULL)
break;
printf("Unknown option '%s'", argv[i]);
cc = tab;
goto subopts;
}
/*
* Look at the next argument. If it doesn't exist or it
* looks like a switch, terminate the scan here.
*/
if (argv[i + 1] == NULL || argv[i + 1][0] == '-') {
if (cc->func != NULL)
break;
printf("Need sub-option for '%s'", argv[i]);
cc = cc->sub;
goto subopts;
}
cc = cc->sub;
i++;
}
argc -= i + 1;
argv += i + 1;
(*cc->func)(argc, argv);
return (0);
subopts:
printf(". Select one of:\n");
while (cc->string != NULL) {
if (cc->func != NULL || cc->sub != NULL)
printf("%s ", cc->string);
cc++;
}
printf("\n");
return (1);
}
static int32_t
snmptool_parse_options(struct snmp_toolinfo *snmptoolctx, int argc, char **argv)
{
int32_t count, optnum = 0;
int ch;
const char *opts;
switch (program) {
case BSNMPWALK:
opts = "dhnKA:b:C:I:i:l:M:N:o:P:p:r:s:t:U:v:";
break;
case BSNMPGET:
opts = "aDdehnKA:b:C:I:i:l:M:N:o:P:p:r:s:t:U:v:";
break;
case BSNMPSET:
opts = "adehnKA:b:C:I:i:l:o:P:r:s:t:U:v:";
break;
default:
return (-1);
}
while ((ch = getopt(argc, argv, opts)) != EOF) {
switch (ch) {
case 'A':
count = parse_authentication(snmptoolctx, optarg);
break;
case 'a':
count = parse_skip_access(snmptoolctx);
break;
case 'b':
count = parse_buflen(optarg);
break;
case 'D':
count = parse_discovery(snmptoolctx);
break;
case 'd':
count = parse_debug();
break;
case 'e':
count = parse_errors(snmptoolctx);
break;
case 'h':
usage();
return (-2);
case 'C':
count = parse_context(snmptoolctx, optarg);
break;
case 'I':
count = parse_include(snmptoolctx, optarg);
break;
case 'i':
count = parse_file(snmptoolctx, optarg);
break;
case 'K':
count = parse_local_key(snmptoolctx);
break;
case 'l':
count = parse_local_path(optarg);
break;
case 'M':
count = parse_max_repetitions(snmptoolctx, optarg);
break;
case 'N':
count = parse_non_repeaters(snmptoolctx, optarg);
break;
case 'n':
count = parse_num_oids(snmptoolctx);
break;
case 'o':
count = parse_output(snmptoolctx, optarg);
break;
case 'P':
count = parse_privacy(snmptoolctx, optarg);
break;
case 'p':
count = parse_pdu_type(snmptoolctx, optarg);
break;
case 'r':
count = parse_retry(optarg);
break;
case 's':
count = parse_server(optarg);
break;
case 't':
count = parse_timeout(optarg);
break;
case 'U':
count = parse_user_security(snmptoolctx, optarg);
break;
case 'v':
count = parse_version(optarg);
break;
case '?':
default:
usage();
return (-1);
}
if (count < 0)
return (-1);
optnum += count;
}
return (optnum);
}
static int parse(struct radproxy_data *cfg, int linenum, char *args[], int argc)
{
char *errmsg = NULL;
static int kwtype = 0;
if (argc <= 0) {
printf("line %d: no parameter\n", linenum);
return -1;
}
if (strcasecmp(args[0], "listen") == 0) {
kwtype = KW_LISTEN;
} else if (strcasecmp(args[0], "client") == 0) {
kwtype = KW_CLIENT;
return 0;
}
/*else {
printf("line %d: unknown keyword '%s'", linenum, args[0]);
return -2;
}*/
switch(kwtype)
{
case KW_CLIENT:
{
struct radproxy_client *c = parse_client(linenum, args, argc);
if (!c)
goto error;
if (!cfg->clients) {
cfg->clients = c;
} else {
struct radproxy_client *p = cfg->clients;
while (p && p->next) p=p->next;
p->next = c;
}
}
break;
case KW_LISTEN:
{
struct radproxy_desc *p;
if (strcasecmp(args[0], "listen") == 0) {
if (argc != 2) {
errmsg = "a port number needed after keyword listen";
goto error;
}
p = calloc(1, sizeof(*p));
if (!p)
goto error;
p->port = atoi(args[1]);
if (p->port <= 0) {
errmsg = "invalid port number";
goto error;
}
if (cfg->proxys) {
struct radproxy_desc *q = cfg->proxys;
while (q && q->next) q = q->next;
q->next = p;
} else {
cfg->proxys = p;
}
break;
}
p = cfg->proxys;
while (p &&p->next) p=p->next;
if (!p) {
errmsg = "go hell";
goto error;
}
if (strcasecmp(args[0], "mode") == 0) {
if (argc != 2) {
goto error;
}
if (strcasecmp(args[1], "radius") == 0) {
p->mode = mode_radius;
} else if (strcasecmp(args[1], "udp") == 0) {
p->mode = mode_udp;
} else {
errmsg = "unknown mode";
goto error;
}
} else if (strcasecmp(args[0], "option") == 0) {
if (argc < 2) {
errmsg = "not enough parameter after keyword option";
goto error;
}
if (strcasecmp(args[1], "state") == 0) {
p->option |= OPTION_STATE;
if (argc != 3) {
errmsg = "a state timeout number needed after 'state'";
goto error;
}
p->state_timeout = atoi(args[2]);
if (p->state_timeout < 0) {
p->state_timeout = 60;
printf("invalid state timeout value '%d', reset to 60s\n", p->state_timeout);
}
p->ht_state = fr_hash_table_create(hash_state, hash_state_cmp, NULL);
} else if (strcasecmp(args[1], "roundrobin") == 0) {
p->option |= OPTION_ROUND_ROBIN;
} else if (strcasecmp(args[1], "source") == 0) {
p->option |= OPTION_SOURCE;
} else if (strcasecmp(args[1], "sign") == 0) {
p->option |= OPTION_SIGN;
} else if (strcasecmp(args[1], "packchk") == 0) {
p->option |= OPTION_PACK_CHECK;
} else if (strcasecmp(args[1], "failover") == 0) {
p->option |= OPTION_FAILOVER;
if (argc != 5) {
errmsg = "parameter 'interv'(s) 'timeout'(ms) 'maxtry' needed after keyword 'failover'";
goto error;
}
p->interv = atoi(args[2]);
p->timeout = atoi(args[3]);
p->maxtry = atoi(args[4]);
if (p->interv <= 0)
p->interv = 10;
if (p->timeout <= 0)
p->timeout = 3000;
if (p->maxtry <= 0)
p->maxtry = 3;
} else {
printf("line %d: unknown keyword '%s'\n", linenum, args[1]);
goto error;
}
} else if (strcasecmp(args[0], "server") == 0) {
struct radproxy_backend_server *s = parse_server(linenum, args+1, argc-1);
if (s) {
struct radproxy_backend_server **q = realloc(p->servers, (p->server_cnt+1)*sizeof(struct radproxy_back_server*));
if (q) {
q[p->server_cnt] = s;
p->servers = q;
p->server_cnt += 1;
}
} else {
goto error;
}
} else if (strcasecmp(args[0], "name") == 0) {
if (argc >= 2) {
if (p->name)
free(p->name);
p->name = strdup(args[1]);
}
}
}
break;
}
return 0;
error:
if (errmsg)
printf("line %d: %s\n", linenum, errmsg);
return 1;
}
int main(int argc, char ** argv)
{
int c;
int flags = MS_MANDLOCK; /* no need to set legacy MS_MGC_VAL */
char * orgoptions = NULL;
char * share_name = NULL;
const char * ipaddr = NULL;
char * uuid = NULL;
char * mountpoint = NULL;
char * options = NULL;
char * optionstail;
char * resolved_path = NULL;
char * temp;
char * dev_name;
int rc = 0;
int rsize = 0;
int wsize = 0;
int nomtab = 0;
int uid = 0;
int gid = 0;
int optlen = 0;
int orgoptlen = 0;
size_t options_size = 0;
size_t current_len;
int retry = 0; /* set when we have to retry mount with uppercase */
struct addrinfo *addrhead = NULL, *addr;
struct stat statbuf;
struct utsname sysinfo;
struct mntent mountent;
struct sockaddr_in *addr4;
struct sockaddr_in6 *addr6;
FILE * pmntfile;
/* setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE); */
if(argc && argv) {
thisprogram = argv[0];
} else {
mount_cifs_usage();
exit(EX_USAGE);
}
if(thisprogram == NULL)
thisprogram = "mount.cifs";
uname(&sysinfo);
/* BB add workstation name and domain and pass down */
/* #ifdef _GNU_SOURCE
printf(" node: %s machine: %s sysname %s domain %s\n", sysinfo.nodename,sysinfo.machine,sysinfo.sysname,sysinfo.domainname);
#endif */
if(argc > 2) {
dev_name = argv[1];
share_name = strndup(argv[1], MAX_UNC_LEN);
if (share_name == NULL) {
fprintf(stderr, "%s: %s", argv[0], strerror(ENOMEM));
exit(EX_SYSERR);
}
mountpoint = argv[2];
} else if (argc == 2) {
if ((strcmp(argv[1], "-V") == 0) ||
(strcmp(argv[1], "--version") == 0))
{
print_cifs_mount_version();
exit(0);
}
if ((strcmp(argv[1], "-h") == 0) ||
(strcmp(argv[1], "-?") == 0) ||
(strcmp(argv[1], "--help") == 0))
{
mount_cifs_usage();
exit(0);
}
mount_cifs_usage();
exit(EX_USAGE);
} else {
mount_cifs_usage();
exit(EX_USAGE);
}
/* add sharename in opts string as unc= parm */
while ((c = getopt_long (argc, argv, "afFhilL:no:O:rsSU:vVwt:",
longopts, NULL)) != -1) {
switch (c) {
/* No code to do the following options yet */
/* case 'l':
list_with_volumelabel = 1;
break;
case 'L':
volumelabel = optarg;
break; */
/* case 'a':
++mount_all;
break; */
case '?':
case 'h': /* help */
mount_cifs_usage ();
exit(EX_USAGE);
case 'n':
++nomtab;
break;
case 'b':
#ifdef MS_BIND
flags |= MS_BIND;
#else
fprintf(stderr,
"option 'b' (MS_BIND) not supported\n");
#endif
break;
case 'm':
#ifdef MS_MOVE
flags |= MS_MOVE;
#else
fprintf(stderr,
"option 'm' (MS_MOVE) not supported\n");
#endif
break;
case 'o':
orgoptions = strdup(optarg);
break;
case 'r': /* mount readonly */
flags |= MS_RDONLY;
break;
case 'U':
uuid = optarg;
break;
case 'v':
++verboseflag;
break;
case 'V':
print_cifs_mount_version();
exit (0);
case 'w':
flags &= ~MS_RDONLY;
break;
case 'R':
rsize = atoi(optarg) ;
break;
case 'W':
wsize = atoi(optarg);
break;
case '1':
if (isdigit(*optarg)) {
char *ep;
uid = strtoul(optarg, &ep, 10);
if (*ep) {
printf("bad uid value \"%s\"\n", optarg);
exit(EX_USAGE);
}
} else {
struct passwd *pw;
if (!(pw = getpwnam(optarg))) {
printf("bad user name \"%s\"\n", optarg);
exit(EX_USAGE);
}
uid = pw->pw_uid;
endpwent();
}
break;
case '2':
if (isdigit(*optarg)) {
char *ep;
gid = strtoul(optarg, &ep, 10);
if (*ep) {
printf("bad gid value \"%s\"\n", optarg);
exit(EX_USAGE);
}
} else {
struct group *gr;
if (!(gr = getgrnam(optarg))) {
printf("bad user name \"%s\"\n", optarg);
exit(EX_USAGE);
}
gid = gr->gr_gid;
endpwent();
}
break;
case 'u':
got_user = 1;
user_name = optarg;
break;
case 'd':
domain_name = optarg; /* BB fix this - currently ignored */
got_domain = 1;
break;
case 'p':
if(mountpassword == NULL)
mountpassword = (char *)calloc(MOUNT_PASSWD_SIZE+1,1);
if(mountpassword) {
got_password = 1;
strlcpy(mountpassword,optarg,MOUNT_PASSWD_SIZE+1);
}
break;
case 'S':
get_password_from_file(0 /* stdin */,NULL);
break;
case 't':
break;
case 'f':
++fakemnt;
break;
default:
printf("unknown mount option %c\n",c);
mount_cifs_usage();
exit(EX_USAGE);
}
}
if((argc < 3) || (dev_name == NULL) || (mountpoint == NULL)) {
mount_cifs_usage();
exit(EX_USAGE);
}
if (getenv("PASSWD")) {
if(mountpassword == NULL)
mountpassword = (char *)calloc(MOUNT_PASSWD_SIZE+1,1);
if(mountpassword) {
strlcpy(mountpassword,getenv("PASSWD"),MOUNT_PASSWD_SIZE+1);
got_password = 1;
}
} else if (getenv("PASSWD_FD")) {
get_password_from_file(atoi(getenv("PASSWD_FD")),NULL);
} else if (getenv("PASSWD_FILE")) {
get_password_from_file(0, getenv("PASSWD_FILE"));
}
if (orgoptions && parse_options(&orgoptions, &flags)) {
rc = EX_USAGE;
goto mount_exit;
}
addrhead = addr = parse_server(&share_name);
if((addrhead == NULL) && (got_ip == 0)) {
printf("No ip address specified and hostname not found\n");
rc = EX_USAGE;
goto mount_exit;
}
/* BB save off path and pop after mount returns? */
resolved_path = (char *)malloc(PATH_MAX+1);
if(resolved_path) {
/* Note that if we can not canonicalize the name, we get
another chance to see if it is valid when we chdir to it */
if (realpath(mountpoint, resolved_path)) {
mountpoint = resolved_path;
}
}
if(chdir(mountpoint)) {
printf("mount error: can not change directory into mount target %s\n",mountpoint);
rc = EX_USAGE;
goto mount_exit;
}
if(stat (".", &statbuf)) {
printf("mount error: mount point %s does not exist\n",mountpoint);
rc = EX_USAGE;
goto mount_exit;
}
if (S_ISDIR(statbuf.st_mode) == 0) {
printf("mount error: mount point %s is not a directory\n",mountpoint);
rc = EX_USAGE;
goto mount_exit;
}
if((getuid() != 0) && (geteuid() == 0)) {
if((statbuf.st_uid == getuid()) && (S_IRWXU == (statbuf.st_mode & S_IRWXU))) {
#ifndef CIFS_ALLOW_USR_SUID
/* Do not allow user mounts to control suid flag
for mount unless explicitly built that way */
flags |= MS_NOSUID | MS_NODEV;
#endif
} else {
printf("mount error: permission denied or not superuser and mount.cifs not installed SUID\n");
exit(EX_USAGE);
}
}
if(got_user == 0) {
/* Note that the password will not be retrieved from the
USER env variable (ie user%password form) as there is
already a PASSWD environment varaible */
if (getenv("USER"))
user_name = strdup(getenv("USER"));
if (user_name == NULL)
user_name = getusername();
got_user = 1;
}
if(got_password == 0) {
char *tmp_pass = getpass("Password: "******"Password not entered, exiting\n");
exit(EX_USAGE);
}
strlcpy(mountpassword, tmp_pass, MOUNT_PASSWD_SIZE+1);
got_password = 1;
}
/* FIXME launch daemon (handles dfs name resolution and credential change)
remember to clear parms and overwrite password field before launching */
if(orgoptions) {
optlen = strlen(orgoptions);
orgoptlen = optlen;
} else
optlen = 0;
if(share_name)
optlen += strlen(share_name) + 4;
else {
printf("No server share name specified\n");
printf("\nMounting the DFS root for server not implemented yet\n");
exit(EX_USAGE);
}
if(user_name)
optlen += strlen(user_name) + 6;
optlen += MAX_ADDRESS_LEN + 4;
if(mountpassword)
optlen += strlen(mountpassword) + 6;
mount_retry:
SAFE_FREE(options);
options_size = optlen + 10 + DOMAIN_SIZE;
options = (char *)malloc(options_size /* space for commas in password */ + 8 /* space for domain= , domain name itself was counted as part of the length username string above */);
if(options == NULL) {
printf("Could not allocate memory for mount options\n");
exit(EX_SYSERR);
}
strlcpy(options, "unc=", options_size);
strlcat(options,share_name,options_size);
/* scan backwards and reverse direction of slash */
temp = strrchr(options, '/');
if(temp > options + 6)
*temp = '\\';
if(user_name) {
/* check for syntax like user=domain\user */
if(got_domain == 0)
domain_name = check_for_domain(&user_name);
strlcat(options,",user="******",domain=",options_size);
strlcat(options,domain_name,options_size);
}
}
strlcat(options,",ver=",options_size);
strlcat(options,MOUNT_CIFS_VERSION_MAJOR,options_size);
if(orgoptions) {
strlcat(options,",",options_size);
strlcat(options,orgoptions,options_size);
}
if(prefixpath) {
strlcat(options,",prefixpath=",options_size);
strlcat(options,prefixpath,options_size); /* no need to cat the / */
}
/* convert all '\\' to '/' in share portion so that /proc/mounts looks pretty */
replace_char(dev_name, '\\', '/', strlen(share_name));
if (!got_ip && addr) {
strlcat(options, ",ip=", options_size);
current_len = strnlen(options, options_size);
optionstail = options + current_len;
switch (addr->ai_addr->sa_family) {
case AF_INET6:
addr6 = (struct sockaddr_in6 *) addr->ai_addr;
ipaddr = inet_ntop(AF_INET6, &addr6->sin6_addr, optionstail,
options_size - current_len);
break;
case AF_INET:
addr4 = (struct sockaddr_in *) addr->ai_addr;
ipaddr = inet_ntop(AF_INET, &addr4->sin_addr, optionstail,
options_size - current_len);
break;
}
/* if the address looks bogus, try the next one */
if (!ipaddr) {
addr = addr->ai_next;
if (addr)
goto mount_retry;
rc = EX_SYSERR;
goto mount_exit;
}
}
if(verboseflag)
fprintf(stderr, "\nmount.cifs kernel mount options: %s", options);
if (mountpassword) {
/*
* Commas have to be doubled, or else they will
* look like the parameter separator
*/
if(retry == 0)
check_for_comma(&mountpassword);
strlcat(options,",pass="******",pass=********");
}
if (verboseflag)
fprintf(stderr, "\n");
if (!fakemnt && mount(dev_name, mountpoint, "cifs", flags, options)) {
switch (errno) {
case ECONNREFUSED:
case EHOSTUNREACH:
if (addr) {
addr = addr->ai_next;
if (addr)
goto mount_retry;
}
break;
case ENODEV:
printf("mount error: cifs filesystem not supported by the system\n");
break;
case ENXIO:
if(retry == 0) {
retry = 1;
if (uppercase_string(dev_name) &&
uppercase_string(share_name) &&
uppercase_string(prefixpath)) {
printf("retrying with upper case share name\n");
goto mount_retry;
}
}
}
printf("mount error(%d): %s\n", errno, strerror(errno));
printf("Refer to the mount.cifs(8) manual page (e.g. man "
"mount.cifs)\n");
rc = EX_FAIL;
goto mount_exit;
}
if (nomtab)
goto mount_exit;
atexit(unlock_mtab);
rc = lock_mtab();
if (rc) {
printf("cannot lock mtab");
goto mount_exit;
}
pmntfile = setmntent(MOUNTED, "a+");
if (!pmntfile) {
printf("could not update mount table\n");
unlock_mtab();
rc = EX_FILEIO;
goto mount_exit;
}
mountent.mnt_fsname = dev_name;
mountent.mnt_dir = mountpoint;
mountent.mnt_type = CONST_DISCARD(char *,"cifs");
mountent.mnt_opts = (char *)malloc(220);
if(mountent.mnt_opts) {
char * mount_user = getusername();
memset(mountent.mnt_opts,0,200);
if(flags & MS_RDONLY)
strlcat(mountent.mnt_opts,"ro",220);
else
strlcat(mountent.mnt_opts,"rw",220);
if(flags & MS_MANDLOCK)
strlcat(mountent.mnt_opts,",mand",220);
if(flags & MS_NOEXEC)
strlcat(mountent.mnt_opts,",noexec",220);
if(flags & MS_NOSUID)
strlcat(mountent.mnt_opts,",nosuid",220);
if(flags & MS_NODEV)
strlcat(mountent.mnt_opts,",nodev",220);
if(flags & MS_SYNCHRONOUS)
strlcat(mountent.mnt_opts,",sync",220);
if(mount_user) {
if(getuid() != 0) {
strlcat(mountent.mnt_opts,
",user=", 220);
strlcat(mountent.mnt_opts,
mount_user, 220);
}
}
}
mountent.mnt_freq = 0;
mountent.mnt_passno = 0;
rc = addmntent(pmntfile,&mountent);
endmntent(pmntfile);
unlock_mtab();
SAFE_FREE(mountent.mnt_opts);
if (rc)
rc = EX_FILEIO;
mount_exit:
if(mountpassword) {
int len = strlen(mountpassword);
memset(mountpassword,0,len);
SAFE_FREE(mountpassword);
}
if (addrhead)
freeaddrinfo(addrhead);
SAFE_FREE(options);
SAFE_FREE(orgoptions);
SAFE_FREE(resolved_path);
SAFE_FREE(share_name);
exit(rc);
}
/**
* Parse connection string and fill login according
* @param connect_string connect string
* @param connect_string_end connect string end (pointer to char past last)
* @param login where to store connection info
* @return 1 if success 0 otherwhise
*/
int
odbc_parse_connect_string(TDS_ERRS *errs, const char *connect_string, const char *connect_string_end, TDSLOGIN * login,
TDS_PARSED_PARAM *parsed_params)
{
const char *p, *end;
DSTR *dest_s, value = DSTR_INITIALIZER;
enum { CFG_DSN = 1, CFG_SERVER = 2, CFG_SERVERNAME = 4 };
unsigned int cfgs = 0; /* flags for indicate second parse of string */
char option[24];
int trusted = 0;
if (parsed_params)
memset(parsed_params, 0, sizeof(*parsed_params)*ODBC_PARAM_SIZE);
for (p = connect_string; p < connect_string_end && *p;) {
int num_param = -1;
dest_s = NULL;
/* handle empty options */
while (p < connect_string_end && *p == ';')
++p;
/* parse option */
end = (const char *) memchr(p, '=', connect_string_end - p);
if (!end)
break;
/* account for spaces between ;'s. */
while (p < end && *p == ' ')
++p;
if ((end - p) >= (int) sizeof(option))
option[0] = 0;
else {
memcpy(option, p, end - p);
option[end - p] = 0;
}
/* parse value */
p = end + 1;
if (*p == '{') {
++p;
/* search "};" */
end = p;
while ((end = (const char *) memchr(end, '}', connect_string_end - end)) != NULL) {
if ((end + 1) != connect_string_end && end[1] == ';')
break;
++end;
}
} else {
end = (const char *) memchr(p, ';', connect_string_end - p);
}
if (!end)
end = connect_string_end;
if (!tds_dstr_copyn(&value, p, end - p)) {
odbc_errs_add(errs, "HY001", NULL);
return 0;
}
#define CHK_PARAM(p) (strcasecmp(option, odbc_param_##p) == 0 && (num_param=ODBC_PARAM_##p) >= 0)
if (CHK_PARAM(Server)) {
/* error if servername or DSN specified */
if ((cfgs & (CFG_DSN|CFG_SERVERNAME)) != 0) {
tds_dstr_free(&value);
odbc_errs_add(errs, "HY000", "Only one between SERVER, SERVERNAME and DSN can be specified");
return 0;
}
if (!cfgs) {
dest_s = &login->server_name;
/* not that safe cast but works -- freddy77 */
if (!parse_server(errs, (char *) tds_dstr_cstr(&value), login)) {
tds_dstr_free(&value);
return 0;
}
cfgs = CFG_SERVER;
}
} else if (CHK_PARAM(Servername)) {
if ((cfgs & (CFG_DSN|CFG_SERVER)) != 0) {
tds_dstr_free(&value);
odbc_errs_add(errs, "HY000", "Only one between SERVER, SERVERNAME and DSN can be specified");
return 0;
}
if (!cfgs) {
odbc_dstr_swap(&login->server_name, &value);
tds_read_conf_file(login, tds_dstr_cstr(&login->server_name));
cfgs = CFG_SERVERNAME;
p = connect_string;
continue;
}
} else if (CHK_PARAM(DSN)) {
if ((cfgs & (CFG_SERVER|CFG_SERVERNAME)) != 0) {
tds_dstr_free(&value);
odbc_errs_add(errs, "HY000", "Only one between SERVER, SERVERNAME and DSN can be specified");
return 0;
}
if (!cfgs) {
if (!odbc_get_dsn_info(errs, tds_dstr_cstr(&value), login)) {
tds_dstr_free(&value);
return 0;
}
cfgs = CFG_DSN;
p = connect_string;
continue;
}
} else if (CHK_PARAM(Database)) {
dest_s = &login->database;
} else if (CHK_PARAM(UID)) {
dest_s = &login->user_name;
} else if (CHK_PARAM(PWD)) {
dest_s = &login->password;
} else if (CHK_PARAM(APP)) {
dest_s = &login->app_name;
} else if (CHK_PARAM(WSID)) {
dest_s = &login->client_host_name;
} else if (CHK_PARAM(Language)) {
tds_parse_conf_section(TDS_STR_LANGUAGE, tds_dstr_cstr(&value), login);
} else if (CHK_PARAM(Port)) {
tds_parse_conf_section(TDS_STR_PORT, tds_dstr_cstr(&value), login);
} else if (CHK_PARAM(TDS_Version)) {
tds_parse_conf_section(TDS_STR_VERSION, tds_dstr_cstr(&value), login);
} else if (CHK_PARAM(TextSize)) {
tds_parse_conf_section(TDS_STR_TEXTSZ, tds_dstr_cstr(&value), login);
} else if (CHK_PARAM(PacketSize)) {
tds_parse_conf_section(TDS_STR_BLKSZ, tds_dstr_cstr(&value), login);
} else if (CHK_PARAM(ClientCharset)) {
tds_parse_conf_section(TDS_STR_CLCHARSET, tds_dstr_cstr(&value), login);
} else if (CHK_PARAM(DumpFile)) {
tds_parse_conf_section(TDS_STR_DUMPFILE, tds_dstr_cstr(&value), login);
} else if (CHK_PARAM(DumpFileAppend)) {
tds_parse_conf_section(TDS_STR_APPENDMODE, tds_dstr_cstr(&value), login);
} else if (CHK_PARAM(DebugFlags)) {
tds_parse_conf_section(TDS_STR_DEBUGFLAGS, tds_dstr_cstr(&value), login);
} else if (CHK_PARAM(Encryption)) {
tds_parse_conf_section(TDS_STR_ENCRYPTION, tds_dstr_cstr(&value), login);
} else if (CHK_PARAM(UseNTLMv2)) {
tds_parse_conf_section(TDS_STR_USENTLMV2, tds_dstr_cstr(&value), login);
} else if (CHK_PARAM(REALM)) {
tds_parse_conf_section(TDS_STR_REALM, tds_dstr_cstr(&value), login);
} else if (CHK_PARAM(ServerSPN)) {
tds_parse_conf_section(TDS_STR_SPN, tds_dstr_cstr(&value), login);
} else if (CHK_PARAM(Trusted_Connection)) {
trusted = tds_config_boolean(option, tds_dstr_cstr(&value), login);
tdsdump_log(TDS_DBG_INFO1, "trusted %s -> %d\n", tds_dstr_cstr(&value), trusted);
num_param = -1;
/* TODO odbc_param_Address field */
} else if (CHK_PARAM(MARS_Connection)) {
if (tds_config_boolean(option, tds_dstr_cstr(&value), login))
login->mars = 1;
} else if (CHK_PARAM(AttachDbFilename)) {
dest_s = &login->db_filename;
} else if (CHK_PARAM(ApplicationIntent)) {
const char *readonly_intent;
if (strcasecmp(tds_dstr_cstr(&value), "ReadOnly") == 0) {
readonly_intent = "yes";
} else if (strcasecmp(tds_dstr_cstr(&value), "ReadWrite") == 0) {
readonly_intent = "no";
} else {
tdsdump_log(TDS_DBG_ERROR, "Invalid ApplicationIntent %s\n", tds_dstr_cstr(&value));
return 0;
}
tds_parse_conf_section(TDS_STR_READONLY_INTENT, readonly_intent, login);
tdsdump_log(TDS_DBG_INFO1, "Application Intent %s\n", readonly_intent);
}
if (num_param >= 0 && parsed_params) {
parsed_params[num_param].p = p;
parsed_params[num_param].len = end - p;
}
/* copy to destination */
if (dest_s)
odbc_dstr_swap(dest_s, &value);
p = end;
/* handle "" ";.." "};.." cases */
if (p >= connect_string_end)
break;
if (*p == '}')
++p;
++p;
}
if (trusted) {
if (parsed_params) {
parsed_params[ODBC_PARAM_Trusted_Connection].p = "Yes";
parsed_params[ODBC_PARAM_Trusted_Connection].len = 3;
parsed_params[ODBC_PARAM_UID].p = NULL;
parsed_params[ODBC_PARAM_PWD].p = NULL;
}
tds_dstr_empty(&login->user_name);
tds_dstr_empty(&login->password);
}
tds_dstr_free(&value);
return 1;
}
/**
* Read connection information from given DSN
* @param DSN DSN name
* @param login where to store connection info
* @return 1 if success 0 otherwhise
*/
int
odbc_get_dsn_info(TDS_ERRS *errs, const char *DSN, TDSLOGIN * login)
{
char tmp[FILENAME_MAX];
int freetds_conf_less = 1;
/* use old servername */
if (myGetPrivateProfileString(DSN, odbc_param_Servername, tmp) > 0) {
freetds_conf_less = 0;
if (!tds_dstr_copy(&login->server_name, tmp)) {
odbc_errs_add(errs, "HY001", NULL);
return 0;
}
tds_read_conf_file(login, tmp);
if (myGetPrivateProfileString(DSN, odbc_param_Server, tmp) > 0) {
odbc_errs_add(errs, "HY000", "You cannot specify both SERVERNAME and SERVER");
return 0;
}
if (myGetPrivateProfileString(DSN, odbc_param_Address, tmp) > 0) {
odbc_errs_add(errs, "HY000", "You cannot specify both SERVERNAME and ADDRESS");
return 0;
}
}
/* search for server (compatible with ms one) */
if (freetds_conf_less) {
int address_specified = 0;
if (myGetPrivateProfileString(DSN, odbc_param_Address, tmp) > 0) {
address_specified = 1;
/* TODO parse like MS */
if (TDS_FAILED(tds_lookup_host_set(tmp, &login->ip_addrs))) {
odbc_errs_add(errs, "HY000", "Error parsing ADDRESS attribute");
return 0;
}
}
if (myGetPrivateProfileString(DSN, odbc_param_Server, tmp) > 0) {
if (!tds_dstr_copy(&login->server_name, tmp)) {
odbc_errs_add(errs, "HY001", NULL);
return 0;
}
if (!address_specified) {
if (!parse_server(errs, tmp, login))
return 0;
}
}
}
if (myGetPrivateProfileString(DSN, odbc_param_Port, tmp) > 0)
tds_parse_conf_section(TDS_STR_PORT, tmp, login);
if (myGetPrivateProfileString(DSN, odbc_param_TDS_Version, tmp) > 0)
tds_parse_conf_section(TDS_STR_VERSION, tmp, login);
if (myGetPrivateProfileString(DSN, odbc_param_Language, tmp) > 0)
tds_parse_conf_section(TDS_STR_LANGUAGE, tmp, login);
if (tds_dstr_isempty(&login->database)
&& myGetPrivateProfileString(DSN, odbc_param_Database, tmp) > 0)
if (!tds_dstr_copy(&login->database, tmp)) {
odbc_errs_add(errs, "HY001", NULL);
return 0;
}
if (myGetPrivateProfileString(DSN, odbc_param_TextSize, tmp) > 0)
tds_parse_conf_section(TDS_STR_TEXTSZ, tmp, login);
if (myGetPrivateProfileString(DSN, odbc_param_PacketSize, tmp) > 0)
tds_parse_conf_section(TDS_STR_BLKSZ, tmp, login);
if (myGetPrivateProfileString(DSN, odbc_param_ClientCharset, tmp) > 0)
tds_parse_conf_section(TDS_STR_CLCHARSET, tmp, login);
if (myGetPrivateProfileString(DSN, odbc_param_DumpFile, tmp) > 0)
tds_parse_conf_section(TDS_STR_DUMPFILE, tmp, login);
if (myGetPrivateProfileString(DSN, odbc_param_DumpFileAppend, tmp) > 0)
tds_parse_conf_section(TDS_STR_APPENDMODE, tmp, login);
if (myGetPrivateProfileString(DSN, odbc_param_DebugFlags, tmp) > 0)
tds_parse_conf_section(TDS_STR_DEBUGFLAGS, tmp, login);
if (myGetPrivateProfileString(DSN, odbc_param_Encryption, tmp) > 0)
tds_parse_conf_section(TDS_STR_ENCRYPTION, tmp, login);
if (myGetPrivateProfileString(DSN, odbc_param_UseNTLMv2, tmp) > 0)
tds_parse_conf_section(TDS_STR_USENTLMV2, tmp, login);
if (myGetPrivateProfileString(DSN, odbc_param_REALM, tmp) > 0)
tds_parse_conf_section(TDS_STR_REALM, tmp, login);
if (myGetPrivateProfileString(DSN, odbc_param_ServerSPN, tmp) > 0)
tds_parse_conf_section(TDS_STR_SPN, tmp, login);
if (myGetPrivateProfileString(DSN, odbc_param_Trusted_Connection, tmp) > 0 && tds_config_boolean(odbc_param_Trusted_Connection, tmp, login)) {
tds_dstr_empty(&login->user_name);
tds_dstr_empty(&login->password);
}
if (myGetPrivateProfileString(DSN, odbc_param_MARS_Connection, tmp) > 0 && tds_config_boolean(odbc_param_MARS_Connection, tmp, login)) {
login->mars = 1;
}
if (myGetPrivateProfileString(DSN, odbc_param_AttachDbFilename, tmp) > 0)
tds_parse_conf_section(TDS_STR_DBFILENAME, tmp, login);
return 1;
}
int main(int argc, char ** argv)
{
int c;
int flags = MS_MANDLOCK; /* no need to set legacy MS_MGC_VAL */
char * orgoptions = NULL;
char * share_name = NULL;
char * domain_name = NULL;
char * ipaddr = NULL;
char * uuid = NULL;
char * mountpoint;
char * options;
char * resolved_path;
char * temp;
int rc;
int rsize = 0;
int wsize = 0;
int nomtab = 0;
int uid = 0;
int gid = 0;
int optlen = 0;
int orgoptlen = 0;
struct stat statbuf;
struct utsname sysinfo;
struct mntent mountent;
FILE * pmntfile;
/* setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE); */
if(argc && argv) {
thisprogram = argv[0];
}
if(thisprogram == NULL)
thisprogram = "mount.cifs";
uname(&sysinfo);
/* BB add workstation name and domain and pass down */
/* #ifdef _GNU_SOURCE
printf(" node: %s machine: %s sysname %s domain %s\n", sysinfo.nodename,sysinfo.machine,sysinfo.sysname,sysinfo.domainname);
#endif */
share_name = argv[1];
mountpoint = argv[2];
/* add sharename in opts string as unc= parm */
while ((c = getopt_long (argc, argv, "afFhilL:no:O:rsU:vVwt:",
longopts, NULL)) != -1) {
switch (c) {
/* No code to do the following options yet */
/* case 'l':
list_with_volumelabel = 1;
break;
case 'L':
volumelabel = optarg;
break; */
/* case 'a':
++mount_all;
break; */
case '?':
case 'h': /* help */
mount_cifs_usage ();
exit(1);
case 'n':
++nomtab;
break;
case 'b':
flags |= MS_BIND;
break;
case 'm':
flags |= MS_MOVE;
break;
case 'o':
orgoptions = strdup(optarg);
break;
case 'r': /* mount readonly */
flags |= MS_RDONLY;
break;
case 'U':
uuid = optarg;
break;
case 'v':
++verboseflag;
break;
case 'V':
printf ("mount.cifs version: %s.%s%s\n",
MOUNT_CIFS_VERSION_MAJOR,
MOUNT_CIFS_VERSION_MINOR,
MOUNT_CIFS_VENDOR_SUFFIX);
if(mountpassword) {
memset(mountpassword,0,64);
}
exit (0);
case 'w':
flags &= ~MS_RDONLY;
break;
case 'R':
rsize = atoi(optarg) ;
break;
case 'W':
wsize = atoi(optarg);
break;
case '1':
uid = atoi(optarg);
break;
case '2':
gid = atoi(optarg);
break;
case 'u':
got_user = 1;
user_name = optarg;
break;
case 'd':
domain_name = optarg;
break;
case 'p':
if(mountpassword == NULL)
mountpassword = calloc(65,1);
if(mountpassword) {
got_password = 1;
strncpy(mountpassword,optarg,64);
}
break;
case 't':
break;
default:
printf("unknown mount option %c\n",c);
mount_cifs_usage();
exit(1);
}
}
if(argc < 3)
mount_cifs_usage();
if (getenv("PASSWD")) {
if(mountpassword == NULL)
mountpassword = calloc(65,1);
if(mountpassword) {
strncpy(mountpassword,getenv("PASSWD"),64);
got_password = 1;
}
} else if (getenv("PASSWD_FD")) {
get_password_from_file(atoi(getenv("PASSWD_FD")),NULL);
} else if (getenv("PASSWD_FILE")) {
get_password_from_file(0, getenv("PASSWD_FILE"));
}
ipaddr = parse_server(share_name);
if(ipaddr == NULL)
return -1;
if (orgoptions && parse_options(orgoptions, &flags))
return -1;
/* BB save off path and pop after mount returns? */
resolved_path = malloc(PATH_MAX+1);
if(resolved_path) {
/* Note that if we can not canonicalize the name, we get
another chance to see if it is valid when we chdir to it */
if (realpath(mountpoint, resolved_path)) {
mountpoint = resolved_path;
}
}
if(chdir(mountpoint)) {
printf("mount error: can not change directory into mount target %s\n",mountpoint);
return -1;
}
if(stat (".", &statbuf)) {
printf("mount error: mount point %s does not exist\n",mountpoint);
return -1;
}
if (S_ISDIR(statbuf.st_mode) == 0) {
printf("mount error: mount point %s is not a directory\n",mountpoint);
return -1;
}
if((getuid() != 0) && (geteuid() == 0)) {
if((statbuf.st_uid == getuid()) && (S_IRWXU == (statbuf.st_mode & S_IRWXU))) {
#ifndef CIFS_ALLOW_USR_SUID
/* Do not allow user mounts to control suid flag
for mount unless explicitly built that way */
flags |= MS_NOSUID | MS_NODEV;
#endif
} else {
printf("mount error: permission denied or not superuser and mount.cifs not installed SUID\n");
return -1;
}
}
if(got_user == 0)
user_name = getusername();
if(got_password == 0) {
mountpassword = getpass("Password: "******"Could not allocate memory for mount options\n");
return -1;
}
options[0] = 0;
strncat(options,"unc=",4);
strcat(options,share_name);
/* scan backwards and reverse direction of slash */
temp = strrchr(options, '/');
if(temp > options + 6)
*temp = '\\';
if(ipaddr) {
strncat(options,",ip=",4);
strcat(options,ipaddr);
}
if(user_name) {
strncat(options,",user="******",pass="******",ver=",5);
strcat(options,MOUNT_CIFS_VERSION_MAJOR);
if(orgoptions) {
strcat(options,",");
strcat(options,orgoptions);
}
if(verboseflag)
printf("\nmount.cifs kernel mount options %s \n",options);
if(mount(share_name, mountpoint, "cifs", flags, options)) {
/* remember to kill daemon on error */
switch (errno) {
case 0:
printf("mount failed but no error number set\n");
break;
case ENODEV:
printf("mount error: cifs filesystem not supported by the system\n");
break;
default:
printf("mount error %d = %s\n",errno,strerror(errno));
}
printf("Refer to the mount.cifs(8) manual page (e.g.man mount.cifs)\n");
if(mountpassword) {
memset(mountpassword,0,64);
}
return -1;
} else {
pmntfile = setmntent(MOUNTED, "a+");
if(pmntfile) {
mountent.mnt_fsname = share_name;
mountent.mnt_dir = mountpoint;
mountent.mnt_type = "cifs";
mountent.mnt_opts = malloc(200);
if(mountent.mnt_opts) {
memset(mountent.mnt_opts,0,200);
if(flags & MS_RDONLY)
strcat(mountent.mnt_opts,"ro");
else
strcat(mountent.mnt_opts,"rw");
if(flags & MS_MANDLOCK)
strcat(mountent.mnt_opts,",mand");
else
strcat(mountent.mnt_opts,",nomand");
if(flags & MS_NOEXEC)
strcat(mountent.mnt_opts,",noexec");
if(flags & MS_NOSUID)
strcat(mountent.mnt_opts,",nosuid");
if(flags & MS_NODEV)
strcat(mountent.mnt_opts,",nodev");
if(flags & MS_SYNCHRONOUS)
strcat(mountent.mnt_opts,",synch");
}
mountent.mnt_freq = 0;
mountent.mnt_passno = 0;
rc = addmntent(pmntfile,&mountent);
endmntent(pmntfile);
if(mountent.mnt_opts)
free(mountent.mnt_opts);
} else {
printf("could not update mount table\n");
}
}
if(mountpassword) {
memset(mountpassword,0,64);
free(mountpassword);
}
if(options) {
memset(options,0,optlen);
free(options);
}
if(orgoptions) {
memset(orgoptions,0,orgoptlen);
free(orgoptions);
}
if(resolved_path) {
free(resolved_path);
}
return 0;
}
static DBusMessage* dbus_read_servers_ex(DBusMessage *message)
{
DBusMessageIter iter, array_iter, string_iter;
DBusMessage *error = NULL;
const char *addr_err;
if (!dbus_message_iter_init(message, &iter))
{
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Failed to initialize dbus message iter");
}
/* check that the message contains an array of arrays */
if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) ||
(dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_ARRAY))
{
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected array of string arrays");
}
mark_dbus();
/* array_iter points to each "as" element in the outer array */
dbus_message_iter_recurse(&iter, &array_iter);
while (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID)
{
const char *str = NULL;
union mysockaddr addr, source_addr;
char interface[IF_NAMESIZE];
char *str_addr;
/* check the types of the struct and its elements */
if ((dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY) ||
(dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_STRING))
{
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected inner array of strings");
break;
}
/* string_iter points to each "s" element in the inner array */
dbus_message_iter_recurse(&array_iter, &string_iter);
if (dbus_message_iter_get_arg_type(&string_iter) != DBUS_TYPE_STRING)
{
/* no IP address given */
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected IP address");
break;
}
dbus_message_iter_get_basic(&string_iter, &str);
if (!str || !strlen (str))
{
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Empty IP address");
break;
}
memset(&addr, 0, sizeof(addr));
memset(&source_addr, 0, sizeof(source_addr));
memset(&interface, 0, sizeof(interface));
/* dup the string because it gets modified during parsing */
str_addr = strdup(str);
if (!str_addr)
{
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Out of memory parsing IP address");
break;
}
/* parse the IP address */
addr_err = parse_server(str_addr, &addr, &source_addr, &interface, NULL);
free(str_addr);
if (addr_err)
{
error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
"Invalid IP address '%s': %s",
str, addr_err);
break;
}
/* jump past the address to the domain list (if any) */
dbus_message_iter_next (&string_iter);
/* parse domains and add each server/domain pair to the list */
do {
str = NULL;
if (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING)
dbus_message_iter_get_basic(&string_iter, &str);
dbus_message_iter_next (&string_iter);
add_update_server(&addr, &source_addr, interface, str);
} while (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING);
/* jump to next element in outer array */
dbus_message_iter_next(&array_iter);
}
cleanup_dbus();
return error;
}
