/********************************************************
find the IP address of the master browser or DMB for a workgroup
*********************************************************/
BOOL
find_master_ip (char *group, struct in_addr * master_ip)
{
if (resolve_name (group, master_ip, 0x1D))
return True;
return resolve_name (group, master_ip, 0x1B);
}
/*
test nbt dgram operations
*/
bool torture_nbt_browse(struct torture_context *torture)
{
const char *address;
struct nbt_name name;
TALLOC_CTX *mem_ctx = talloc_new(NULL);
NTSTATUS status;
bool ret = true;
name.name = lpcfg_workgroup();
name.type = NBT_NAME_BROWSER;
name.scope = NULL;
/* do an initial name resolution to find its IP */
status = resolve_name(&name, mem_ctx, &address, torture->ev);
if (!NT_STATUS_IS_OK(status)) {
printf("Failed to resolve %s - %s\n",
name.name, nt_errstr(status));
talloc_free(mem_ctx);
return false;
}
talloc_free(mem_ctx);
return ret;
}
/****************************************************************************
open the client sockets
****************************************************************************/
BOOL cli_connect(struct cli_state *cli, const char *host, struct in_addr *ip)
{
extern pstring user_socket_options;
int fd;
fstrcpy(cli->desthost, host);
if (!ip || ip->s_addr == 0)
{
if (!resolve_name(cli->desthost, &cli->dest_ip, 0x20))
{
return False;
}
if (ip)
*ip = cli->dest_ip;
}
else
{
cli->dest_ip = *ip;
}
if (cli->port == 0)
cli->port = 139; /* Set to default */
fd = open_socket_out(SOCK_STREAM, &cli->dest_ip,
cli->port, 20000);
if (fd == -1 || !smb_set_fd(cli->hnd, fd))
return False;
set_socket_options(fd, user_socket_options);
return True;
}
/* lookup a hostname giving an IP */
static int net_lookup_host(int argc, const char **argv)
{
struct in_addr ip;
int name_type = 0x20;
const char *name = argv[0];
char *p;
if (argc == 0)
return net_lookup_usage(argc, argv);
p = strchr_m(name,'#');
if (p) {
*p = '\0';
sscanf(++p,"%x",&name_type);
}
if (!resolve_name(name, &ip, name_type)) {
/* we deliberately use DEBUG() here to send it to stderr
so scripts aren't mucked up */
DEBUG(0,("Didn't find %s#%02x\n", name, name_type));
return -1;
}
d_printf("%s\n", inet_ntoa(ip));
return 0;
}
static inline int samba_resolve_name(const char *name, struct in_addr *return_ip, int name_type)
{
struct sockaddr_storage addr;
int res = resolve_name(name, &addr, name_type);
*return_ip = ((struct sockaddr_in*)&addr)->sin_addr;
return res;
}
/* lookup a hostname giving an IP */
static int net_lookup_host(struct net_context *c, int argc, const char **argv)
{
struct sockaddr_storage ss;
int name_type = 0x20;
char addr[INET6_ADDRSTRLEN];
const char *name = argv[0];
char *p;
if (argc == 0)
return net_lookup_usage(c, argc, argv);
p = strchr_m(name,'#');
if (p) {
*p = '\0';
sscanf(++p,"%x",&name_type);
}
if (!resolve_name(name, &ss, name_type, false)) {
/* we deliberately use DEBUG() here to send it to stderr
so scripts aren't mucked up */
DEBUG(0,("Didn't find %s#%02x\n", name, name_type));
return -1;
}
print_sockaddr(addr, sizeof(addr), &ss);
d_printf("%s\n", addr);
return 0;
}
asmlinkage long virt_lstat64(char * filename, struct stat64 * statbuf, long flags)
{
long ret;
char *newfilename;
if(!cwd_virtual()) {
ret = (*orig_lstat64)(filename, statbuf, flags);
if(ret != -ENOENT)
return ret;
}
else
ret = 0;
newfilename = resolve_name(filename, 1, 0);
if(!newfilename) {
if(ret)
return ret;
else
return (*orig_lstat64)(filename, statbuf, flags);
}
if(IS_ERR(newfilename))
return PTR_ERR(newfilename);
DEB((KERN_INFO "LSTAT64: trying '%s'\n", newfilename));
ret = do_orig_stat64(orig_lstat64, newfilename, statbuf, flags);
kfree(newfilename);
DEB((KERN_INFO "LSTAT64: result %li\n", ret));
return ret;
}
asmlinkage int virt_lstat(const char *filename, struct stat *statbuf)
{
int ret;
char *newfilename;
if(!cwd_virtual()) {
ret = (*orig_lstat)(filename, statbuf);
if(ret != -ENOENT)
return ret;
}
else
ret = 0;
newfilename = resolve_name(filename, 1, 0);
if(!newfilename) {
if(ret)
return ret;
else
return (*orig_lstat)(filename, statbuf);
}
if(IS_ERR(newfilename))
return PTR_ERR(newfilename);
DEB((KERN_INFO "LSTAT: trying '%s'\n", newfilename));
ret = do_orig_stat(orig_lstat, newfilename, statbuf);
kfree(newfilename);
DEB((KERN_INFO "LSTAT: result %i\n", ret));
return ret;
}
// load a unicast address from configuration
int load_subscriber_address(struct subscriber *subscriber)
{
if (subscriber_is_reachable(subscriber)&REACHABLE)
return 0;
int i = config_host_list__get(&config.hosts, (const sid_t*)subscriber->sid);
// No unicast configuration? just return.
if (i == -1)
return 1;
const struct config_host *hostc = &config.hosts.av[i].value;
overlay_interface *interface = NULL;
if (*hostc->interface){
interface = overlay_interface_find_name(hostc->interface);
if (!interface)
return WHY("Can't fund configured interface");
}
struct sockaddr_in addr;
bzero(&addr, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr = hostc->address;
addr.sin_port = htons(hostc->port);
if (addr.sin_addr.s_addr==INADDR_NONE){
if (interface || overlay_interface_get_default()){
if (resolve_name(hostc->host, &addr.sin_addr))
return -1;
}else{
// interface isnt up yet
return 1;
}
}
if (config.debug.overlayrouting)
DEBUGF("Loaded address %s:%d for %s", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port), alloca_tohex_sid(subscriber->sid));
return overlay_send_probe(subscriber, addr, interface, OQ_MESH_MANAGEMENT);
}
int SockLib::client_init(const char *servername) {
if (servername == 0) {
SysLogger::inst()->err("init params error");
return -1;
}
if (init()) {
SysLogger::inst()->err("socket init error");
return -1;
}
SysLogger::inst()->out("ftp_tcp starting on host: [%s]", hostname);
//connect to the server
memset(&ServerAddr, 0, sizeof(ServerAddr)); /* Zero out structure */
ServerAddr.sin_family = AF_INET; /* Internet address family */
ServerAddr.sin_addr.s_addr = resolve_name(servername); /* Server IP address */
ServerAddr.sin_port = htons(SERVER_RECV_PORT); /* Server port */
if (connect(sock, (struct sockaddr *) &ServerAddr, sizeof(ServerAddr)) < 0) {
SysLogger::inst()->err("Faild to connect to server: %s", servername);
//closesocket(sock);
//WSACleanup();
return -1;
}
return 0;
}
static void print_ldap_srvlist(struct dns_rr_srv *dclist, int numdcs )
{
struct in_addr ip;
int i;
for ( i=0; i<numdcs; i++ ) {
if ( resolve_name(dclist[i].hostname, &ip, 0x20) ) {
d_printf("%s:%d\n", inet_ntoa(ip), dclist[i].port);
}
}
}
char *
_XlcFileName(
XLCd lcd,
const char *category)
{
char *siname;
char cat[XLC_BUFSIZE], dir[XLC_BUFSIZE];
int i, n;
char *args[NUM_LOCALEDIR];
char *file_name = NULL;
if (lcd == (XLCd)NULL)
return NULL;
siname = XLC_PUBLIC(lcd, siname);
if (category)
lowercase(cat, category);
else
cat[0] = '\0';
xlocaledir(dir,XLC_BUFSIZE);
n = _XlcParsePath(dir, args, NUM_LOCALEDIR);
for (i = 0; i < n; ++i) {
char buf[PATH_MAX], *name;
if (args[i] == NULL)
continue;
name = NULL;
if (snprintf(buf, PATH_MAX, "%s/%s.dir", args[i], cat) < PATH_MAX) {
name = resolve_name(siname, buf, RtoL);
}
if (name == NULL) {
continue;
}
if (*name == '/') {
/* supposed to be absolute path name */
file_name = name;
} else {
if (snprintf(buf, PATH_MAX, "%s/%s", args[i], name) < PATH_MAX)
file_name = strdup(buf);
else
file_name = NULL;
Xfree(name);
}
if (file_name && isreadable(file_name)) {
break;
}
Xfree(file_name);
file_name = NULL;
/* Then, try with next dir */
}
return file_name;
}
asmlinkage int virt_readlink(const char *filename, char *buf, int bufsiz)
{
int ret;
mm_segment_t old_fs;
char *newfilename;
char *locbuf;
int len;
if(!cwd_virtual()) {
ret = (*orig_readlink)(filename, buf, bufsiz);
if(ret != -ENOENT)
return ret;
}
else
ret = 0;
newfilename = resolve_name(filename, 1, 0);
if(!newfilename) {
if(ret)
return ret;
else
return (*orig_readlink)(filename, buf, bufsiz);
}
if(IS_ERR(newfilename))
return PTR_ERR(newfilename);
DEB((KERN_INFO "READLINK: trying '%s'\n", newfilename));
/* bufsiz is legal (already checked by sys_readlink) */
len = bufsiz;
if(bufsiz > PAGE_SIZE)
len = PAGE_SIZE;
locbuf = (char *) __get_free_page(GFP_USER);
ret = -ENOMEM;
if(locbuf) {
old_fs = get_fs();
set_fs(get_ds());
ret = (*orig_readlink)(newfilename, locbuf, len);
set_fs(old_fs);
if(ret >= 0)
if(copy_to_user(buf, locbuf, len))
ret = -EFAULT;
free_page((unsigned long) locbuf);
}
kfree(newfilename);
DEB((KERN_INFO "READLINK: result %i\n", ret));
return ret;
}
int main(int argc, char *argv[])
{
struct addrset *set;
char line[1024];
int i;
#ifdef WIN32
win_init();
#endif
set = addrset_new();
options_init();
for (i = 1; i < argc; i++) {
if (!addrset_add_spec(set, argv[i], o.af, !o.nodns)) {
fprintf(stderr, "Error adding spec \"%s\".\n", argv[i]);
exit(1);
}
}
while (fgets(line, sizeof(line), stdin) != NULL) {
char *s, *hostname;
struct addrinfo *addrs;
s = line;
while ((hostname = strtok(s, " \t\n")) != NULL) {
int rc;
s = NULL;
rc = resolve_name(hostname, &addrs);
if (rc != 0) {
fprintf(stderr, "Error resolving \"%s\": %s.\n", hostname, gai_strerror(rc));
continue;
}
if (addrs == NULL) {
fprintf(stderr, "No addresses found for \"%s\".\n", hostname);
continue;
}
/* Check just the first address returned. */
if (addrset_contains(set, addrs->ai_addr))
printf("%s\n", hostname);
freeaddrinfo(addrs);
}
}
addrset_free(set);
return 0;
}
BOOL cli_connect(struct cli_state *cli, const char *host, struct in_addr *ip)
{
extern pstring user_socket_options;
int name_type = 0x20;
char *p;
/* reasonable default hostname */
if (!host)
host = "*SMBSERVER";
fstrcpy(cli->desthost, host);
/* allow hostnames of the form NAME#xx and do a netbios lookup */
if ((p = strchr(cli->desthost, '#'))) {
name_type = strtol(p+1, NULL, 16);
*p = 0;
}
if (!ip || is_zero_ip(*ip)) {
if (!resolve_name(cli->desthost, &cli->dest_ip, name_type)) {
return False;
}
if (ip)
*ip = cli->dest_ip;
} else {
cli->dest_ip = *ip;
}
if (getenv("LIBSMB_PROG")) {
cli->fd = sock_exec(getenv("LIBSMB_PROG"));
} else {
/* try 445 first, then 139 */
int port = cli->port?cli->port:445;
cli->fd = open_socket_out(SOCK_STREAM, &cli->dest_ip,
port, cli->timeout);
if (cli->fd == -1 && cli->port == 0) {
port = 139;
cli->fd = open_socket_out(SOCK_STREAM, &cli->dest_ip,
port, cli->timeout);
}
if (cli->fd != -1) cli->port = port;
}
if (cli->fd == -1) {
DEBUG(1,("Error connecting to %s (%s)\n",
inet_ntoa(*ip),strerror(errno)));
return False;
}
set_socket_options(cli->fd,user_socket_options);
return True;
}
int SockLib::set_dstAddr(const char *dstHostName, int dstPort) {
if (dstHostName == 0) {
SysLogger::inst()->err("set_dstAddr params error");
return -1;
}
// specify destination address
memset(&dstAddr, 0, sizeof(dstAddr));
dstAddr.sin_family = AF_INET;
dstAddr.sin_addr.s_addr = resolve_name(dstHostName);
dstAddr.sin_port = htons(dstPort);
return 0;
}
char *
_XlcFileName(
XLCd lcd,
const char *category)
{
char *siname;
char cat[XLC_BUFSIZE], dir[XLC_BUFSIZE];
int i, n;
char *args[NUM_LOCALEDIR];
char *file_name = NULL;
if (lcd == (XLCd)NULL)
return NULL;
siname = XLC_PUBLIC(lcd, siname);
lowercase(cat, category);
xlocaledir(dir,XLC_BUFSIZE);
n = _XlcParsePath(dir, args, NUM_LOCALEDIR);
for (i = 0; i < n; ++i) {
char buf[PATH_MAX], *name;
name = NULL;
if ((5 + (args[i] ? strlen (args[i]) : 0) +
(cat ? strlen (cat) : 0)) < PATH_MAX) {
sprintf(buf, "%s/%s.dir", args[i], cat);
name = resolve_name(siname, buf, RtoL);
}
if (name == NULL) {
continue;
}
if (*name == '/') {
/* supposed to be absolute path name */
file_name = name;
} else {
file_name = Xmalloc(2 + (args[i] ? strlen (args[i]) : 0) +
(name ? strlen (name) : 0));
if (file_name != NULL)
sprintf(file_name, "%s/%s", args[i], name);
Xfree(name);
}
if (isreadable(file_name)) {
break;
}
Xfree(file_name);
file_name = NULL;
/* Then, try with next dir */
}
return file_name;
}
static int ejs_resolve_name(MprVarHandle eid, int argc, struct MprVar **argv)
{
int result = -1;
struct nbt_name name;
TALLOC_CTX *tmp_ctx = talloc_new(mprMemCtx());
NTSTATUS nt_status;
const char *reply_addr;
/* validate arguments */
if (argc < 2 || argc > 3) {
ejsSetErrorMsg(eid, "resolveName invalid arguments");
goto done;
}
if (argv[0]->type != MPR_TYPE_OBJECT) {
ejsSetErrorMsg(eid, "resolvename invalid arguments");
goto done;
}
if (argv[1]->type != MPR_TYPE_STRING) {
ejsSetErrorMsg(eid, "resolveName invalid arguments");
goto done;
}
if (argc == 2) {
make_nbt_name_client(&name, mprToString(argv[1]));
} else {
if (!mprVarIsNumber(argv[1]->type)) {
ejsSetErrorMsg(eid, "resolveName invalid arguments");
goto done;
}
make_nbt_name(&name, mprToString(argv[1]), mprToInt(argv[2]));
}
result = 0;
nt_status = resolve_name(&name, tmp_ctx, &reply_addr, event_context_find(tmp_ctx));
if (NT_STATUS_IS_OK(nt_status)) {
mprSetPropertyValue(argv[0], "value", mprString(reply_addr));
}
mpr_Return(eid, mprNTSTATUS(nt_status));
done:
talloc_free(tmp_ctx);
return result;
}
static void start_filter(char *desthost)
{
int s, c;
struct in_addr dest_ip;
CatchChild();
/* start listening on port 445 locally */
s = open_socket_in(SOCK_STREAM, 445, 0, 0, True);
if (s == -1) {
d_printf("bind failed\n");
exit(1);
}
if (listen(s, 5) == -1) {
d_printf("listen failed\n");
}
if (!resolve_name(desthost, &dest_ip, 0x20)) {
d_printf("Unable to resolve host %s\n", desthost);
exit(1);
}
while (1) {
fd_set fds;
int num;
struct sockaddr addr;
socklen_t in_addrlen = sizeof(addr);
FD_ZERO(&fds);
FD_SET(s, &fds);
num = sys_select_intr(s+1,&fds,NULL,NULL,NULL);
if (num > 0) {
c = accept(s, &addr, &in_addrlen);
if (c != -1) {
if (fork() == 0) {
close(s);
filter_child(c, dest_ip);
exit(0);
} else {
close(c);
}
}
}
}
}
static void start_filter(char *desthost)
{
int s, c;
struct sockaddr_storage dest_ss;
struct sockaddr_storage my_ss;
CatchChild();
/* start listening on port 445 locally */
zero_sockaddr(&my_ss);
s = open_socket_in(SOCK_STREAM, TCP_SMB_PORT, 0, &my_ss, True);
if (s == -1) {
d_printf("bind failed\n");
exit(1);
}
if (listen(s, 5) == -1) {
d_printf("listen failed\n");
}
if (!resolve_name(desthost, &dest_ss, 0x20, false)) {
d_printf("Unable to resolve host %s\n", desthost);
exit(1);
}
while (1) {
int num, revents;
struct sockaddr_storage ss;
socklen_t in_addrlen = sizeof(ss);
num = poll_intr_one_fd(s, POLLIN|POLLHUP, -1, &revents);
if ((num > 0) && (revents & (POLLIN|POLLHUP|POLLERR))) {
c = accept(s, (struct sockaddr *)&ss, &in_addrlen);
if (c != -1) {
if (fork() == 0) {
close(s);
filter_child(c, &dest_ss);
exit(0);
} else {
close(c);
}
}
}
}
}
static BOOL get_dc_name_via_netlogon(const struct winbindd_domain *domain,
fstring dcname, struct in_addr *dc_ip)
{
struct winbindd_domain *our_domain;
NTSTATUS result;
struct winbindd_cm_conn *conn;
TALLOC_CTX *mem_ctx;
fstring tmp;
char *p;
if (IS_DC)
return False;
if (domain->primary)
return False;
if ((our_domain = find_our_domain()) == NULL)
return False;
result = get_connection_from_cache(our_domain, PIPE_NETLOGON, &conn);
if (!NT_STATUS_IS_OK(result))
return False;
if ((mem_ctx = talloc_init("get_dc_name_via_netlogon")) == NULL)
return False;
result = cli_netlogon_getdcname(conn->cli, mem_ctx, domain->name, tmp);
talloc_destroy(mem_ctx);
if (!NT_STATUS_IS_OK(result))
return False;
/* cli_netlogon_getdcname gives us a name with \\ */
p = tmp;
if (*p == '\\') p+=1;
if (*p == '\\') p+=1;
fstrcpy(dcname, p);
if (!resolve_name(dcname, dc_ip, 0x20))
return False;
return True;
}
void
setpeer (int argc, char *argv[])
{
if (argc < 2)
get_args ("Connect", "(to) ", &argc, &argv);
if (argc < 2 || argc > 3)
{
printf ("usage: %s host-name [port]\n", argv[0]);
return;
}
switch (resolve_name (argv[1], 1))
{
case RESOLVE_OK:
break;
case RESOLVE_FAIL:
return;
case RESOLVE_NOT_RESOLVED:
peeraddr.sin_family = AF_INET;
peeraddr.sin_addr.s_addr = inet_addr (argv[1]);
if (peeraddr.sin_addr.s_addr == -1)
{
connected = 0;
printf ("%s: unknown host\n", argv[1]);
return;
}
hostname = xstrdup (argv[1]);
}
port = sp->s_port;
if (argc == 3)
{
port = atoi (argv[2]);
if (port < 0)
{
printf ("%s: bad port number\n", argv[2]);
connected = 0;
return;
}
port = htons (port);
}
connected = 1;
}
/** Resolve name and wait for the result.
* This will lookup a name from the cache and return the value if available.
* If there is no entry in the cache this will order a concurrent lookup of the
* name and wait for the result.
* @param name name to resolve
* @param addr contains a pointer to the address record upon return, this record
* is in the cache, so you may not free the resulting address! The address is
* always of type struct sockaddr_in (IPv4) at the moment.
* @param addrlen contains the length of addr in bytes upon return
* @return true if resolution was successful, false otherwise
*/
bool
NetworkNameResolver::resolve_name_blocking(const char *name,
struct sockaddr **addr, socklen_t *addrlen)
{
if ( resolve_name(name, addr, addrlen) ) {
return true;
} else {
struct sockaddr *_addr;
socklen_t _addrlen;
if ( resolver_thread->resolve_name_immediately(name, &_addr, &_addrlen) ) {
name_resolved(strdup(name), _addr, _addrlen);
*addr = _addr;
*addrlen = _addrlen;
return true;
} else {
return false;
}
}
}
static void print_ldap_srvlist(struct dns_rr_srv *dclist, int numdcs )
{
struct sockaddr_storage ss;
int i;
for ( i=0; i<numdcs; i++ ) {
if (resolve_name(dclist[i].hostname, &ss, 0x20, true) ) {
char addr[INET6_ADDRSTRLEN];
print_sockaddr(addr, sizeof(addr), &ss);
#ifdef HAVE_IPV6
if (ss.ss_family == AF_INET6) {
d_printf("[%s]:%d\n", addr, dclist[i].port);
}
#endif
if (ss.ss_family == AF_INET) {
d_printf("%s:%d\n", addr, dclist[i].port);
}
}
}
}
static void print_ldap_srvlist(char *srvlist)
{
char *cur, *next;
struct in_addr ip;
BOOL printit;
cur = srvlist;
do {
next = strchr(cur,':');
if (next) *next++='\0';
printit = resolve_name(cur, &ip, 0x20);
cur=next;
next=cur ? strchr(cur,' ') :NULL;
if (next)
*next++='\0';
if (printit)
d_printf("%s:%s\n", inet_ntoa(ip), cur?cur:"");
cur = next;
} while (next);
}
asmlinkage int virt_execve(struct pt_regs regs)
{
int ret;
char *newfilename;
char *filename = (char *) regs.ebx;
if(!cwd_virtual()) {
ret = real_execve(®s);
if(ret != -ENOENT)
return ret;
}
else
ret = 0;
newfilename = resolve_name(filename, 1, 1);
if(!newfilename) {
if(ret)
return ret;
else
return real_execve(®s);
}
if(IS_ERR(newfilename))
return PTR_ERR(newfilename);
DEB((KERN_INFO "EXECVE: trying '%s'\n", newfilename));
ret = do_execve(newfilename, (char **) regs.ecx, (char **) regs.edx,
®s);
if (ret == 0) {
#ifdef PT_DTRACE
current->ptrace &= ~PT_DTRACE;
#else
current->flags &= ~PF_DTRACE;
#endif
}
kfree(newfilename);
DEB((KERN_INFO "EXECVE: result %i\n", ret));
return ret;
}
static void continue_build(build *current, char *filename, file_contents newest) {
slice name_slice = new_slice(filename);
slice *boxed_slice = new(boxed_slice);
*boxed_slice = name_slice;
hm_put(current->declarations, slice_hash(name_slice), boxed_slice, filename);
linked_iter iterator = ll_iter_head(newest.imports);
while(ll_iter_has_next(&iterator)) {
import_declaration *dec = ll_iter_next(&iterator);
char *filename = resolve_name(dec->name);
slice filename_slice = new_slice(filename);
slice *boxed_filename = new(boxed_filename);
*boxed_filename = filename_slice;
if(!hm_has(current->declarations, slice_hash(filename_slice), &(filename_slice))) {
file_contents contents = get_contents(filename);
ll_concat(current->composite.structs, contents.structs);
ll_concat(current->composite.functions, contents.functions);
hm_put(current->declarations, slice_hash(filename_slice), boxed_filename, filename);
continue_build(current, filename, contents);
}
}
}
char *
get_locale_compose_file_path(const char *locale)
{
int ret;
const char *xlocaledir;
char *resolved;
char *path;
/*
* WARNING: Random workaround ahead.
*
* We currently do not support non-UTF-8 Compose files. The C/POSIX
* locale is specified to be the default fallback locale with an
* ASCII charset. But for some reason the compose.dir points the C
* locale to the iso8859-1/Compose file, which is not ASCII but
* ISO8859-1. Since this is bound to happen a lot, and since our API
* is UTF-8 based, and since 99% of the time a C locale is really just
* a misconfiguration for UTF-8, let's do the most helpful thing.
*/
if (streq(locale, "C"))
locale = "en_US.UTF-8";
resolved = resolve_name("compose.dir", RIGHT_TO_LEFT, locale);
if (!resolved)
return NULL;
if (resolved[0] == '/') {
path = resolved;
}
else {
xlocaledir = get_xlocaledir_path();
ret = asprintf(&path, "%s/%s", xlocaledir, resolved);
free(resolved);
if (ret < 0)
return NULL;
}
return path;
}
void parse_cmdline(int argc, char* argv[])
{
int c;
struct option options[] = {
{ "verbose", no_argument, &verbose, 1 },
{ "numeric", no_argument, &numeric, 1 },
{ "listen", required_argument, 0, 'l' },
{ "prefix", required_argument, 0, 'p' },
};
struct addrinfo **a;
while ((c = getopt_long_only(argc, argv, "l:p:", options, NULL)) != -1) {
if (c == 0) continue;
switch (c) {
case 'l':
/* find the end of the listen list */
for (a = &addr_listen; *a; a = &((*a)->ai_next));
/* append the specified addresses */
resolve_name(a, optarg);
break;
case 'p':
prefix = optarg;
break;
default:
fprintf(stderr, "%s", USAGE_STRING);
exit(2);
}
}
if (!addr_listen) {
fprintf(stderr, "No listening port specified\n");
exit(1);
}
}
asmlinkage int virt_chdir(const char *filename)
{
int ret;
mm_segment_t old_fs;
char *newfilename;
if(!cwd_virtual()) {
ret = (*orig_chdir)(filename);
if(ret != -ENOENT)
return ret;
}
else
ret = 0;
newfilename = resolve_name(filename, 1, 1);
if(!newfilename) {
if(ret)
return ret;
else
return (*orig_chdir)(filename);
}
if(IS_ERR(newfilename))
return PTR_ERR(newfilename);
DEB((KERN_INFO "CHDIR: trying '%s'\n", newfilename));
old_fs = get_fs();
set_fs(get_ds());
ret = (*orig_chdir)(newfilename);
set_fs(old_fs);
kfree(newfilename);
DEB((KERN_INFO "CHDIR: result %i\n", ret));
return ret;
}
