{

const char *dir = getenv("FISHD_SOCKET_DIR");

char *uname = getenv("USER");

if (dir == NULL)

{

dir = "/tmp";

}

if (uname == NULL)

{

const struct passwd *pw = getpwuid(getuid());

uname = pw->pw_name;

}

std::string name;

name.reserve(strlen(dir)+ strlen(uname)+ strlen(SOCK_FILENAME) + 1);

name.append(dir);

name.push_back('/');

name.append(SOCK_FILENAME);

name.append(uname);

if (name.size() >= UNIX_PATH_MAX)

{

debug(1, L"Filename too long: '%s'", name.c_str());

exit(EXIT_FAILURE);

}

return name;

{

int i, max;

struct timeval tv;

/*

static bool seeded = false;

if (! seeded)

{

(void)gettimeofday(&tv, NULL);

unsigned long long seed = tv.tv_sec + tv.tv_usec * 1000000ULL;

srand((unsigned int)seed);

seeded = true;

}

max = (int)(1 + (maxlen - 1) * (rand() / (RAND_MAX + 1.0)));

for (i = 0; i < max; i++)

{

str[i] = '0' + 10 * (rand() / (RAND_MAX + 1.0));

}

str[i] = 0;

{

char hostname[HOST_NAME_MAX + 1];

char pid_str[256];

snprintf(pid_str, sizeof pid_str, "%ld", (long)getpid());

if (gethostname(hostname, sizeof hostname) != 0)

{

sprint_rand_digits(hostname, HOST_NAME_MAX);

}

std::string newname(filename);

newname.push_back('.');

newname.append(hostname);

newname.push_back('.');

newname.append(pid_str);

return newname;

{

bool result = false;

const int dummy = socket(AF_INET, SOCK_STREAM, 0);

if (dummy >= 0)

{

struct ifreq r;

strncpy((char *)r.ifr_name, interface, sizeof r.ifr_name - 1);

r.ifr_name[sizeof r.ifr_name - 1] = 0;

if (ioctl(dummy, SIOCGIFHWADDR, &r) >= 0)

{

memcpy(macaddr, r.ifr_hwaddr.sa_data, MAC_ADDRESS_MAX_LEN);

result = true;

}

close(dummy);

}

return result;

{

// BSD, Mac OS X

struct ifaddrs *ifap;

bool ok = false;

if (getifaddrs(&ifap) == 0)

{

for (const ifaddrs *p = ifap; p; p = p->ifa_next)

{

if (p->ifa_addr->sa_family == AF_LINK)

{

if (p->ifa_name && p->ifa_name[0] &&

! strcmp((const char*)p->ifa_name, interface))

{

const sockaddr_dl& sdl = *(sockaddr_dl*)p->ifa_addr;

size_t alen = sdl.sdl_alen;

if (alen > MAC_ADDRESS_MAX_LEN) alen = MAC_ADDRESS_MAX_LEN;

memcpy(macaddr, sdl.sdl_data + sdl.sdl_nlen, alen);

ok = true;

break;

}

}

}

freeifaddrs(ifap);

}

return ok;

{

bool success = false;

char hostname[HOSTNAME_LEN + 1] = {};

if (gethostname(hostname, HOSTNAME_LEN) == 0)

{

result->assign(hostname);

success = true;

}

return success;

{

std::string result;

unsigned char mac_addr[MAC_ADDRESS_MAX_LEN] = {};

if (get_mac_address(mac_addr))

{

result.reserve(2 * MAC_ADDRESS_MAX_LEN);

for (size_t i=0; i < MAC_ADDRESS_MAX_LEN; i++)

{

char buff[3];

snprintf(buff, sizeof buff, "%02x", mac_addr[i]);

result.append(buff);

}

}

else if (get_hostname_identifier(&result))

{

/* Hooray */

}

else

{

/* Fallback */

result.assign("nohost");

}

return result;

{

int fd, timed_out = 0;

int ret = 0; /* early exit returns failure */

struct timespec pollint;

struct timeval start, end;

double elapsed;

struct stat statbuf;

const char * const lockfile = lockfile_str.c_str();

/*

const std::string linkfile_str = gen_unique_nfs_filename(lockfile);

const char * const linkfile = linkfile_str.c_str();

(void)unlink(linkfile);

/* OK to not use CLO_EXEC here because fishd is single threaded */

if ((fd = open(linkfile, O_CREAT|O_RDONLY, 0600)) == -1)

{

debug(1, L"acquire_lock_file: open: %s", strerror(errno));

goto done;

}

/*

close(fd);

if (stat(linkfile, &statbuf) != 0)

{

debug(1, L"acquire_lock_file: stat: %s", strerror(errno));

goto done;

}

if (statbuf.st_nlink != 1)

{

debug(1, L"acquire_lock_file: number of hardlinks on unique "

L"tmpfile is %d instead of 1.", (int)statbuf.st_nlink);

goto done;

}

if (gettimeofday(&start, NULL) != 0)

{

debug(1, L"acquire_lock_file: gettimeofday: %s", strerror(errno));

goto done;

}

end = start;

pollint.tv_sec = 0;

pollint.tv_nsec = LOCKPOLLINTERVAL * 1000000;

do

{

/*

if (link(linkfile, lockfile) == 0 ||

(stat(linkfile, &statbuf) == 0 &&

statbuf.st_nlink == 2))

{

/* Successful lock */

ret = 1;

break;

}

elapsed = end.tv_sec + end.tv_usec/1000000.0 -

(start.tv_sec + start.tv_usec/1000000.0);

/*

if (timed_out || elapsed >= timeout || elapsed < 0)

{

if (timed_out == 0 && force)

{

/*

(void)unlink(lockfile);

timed_out = 1;

continue;

}

else

{

/*

debug(1, L"acquire_lock_file: timed out "

L"trying to obtain lockfile %s using "

L"linkfile %s", lockfile, linkfile);

break;

}

}

nanosleep(&pollint, NULL);

}

while (gettimeofday(&end, NULL) == 0);

done:

/* The linkfile is not needed once the lockfile has been created */

(void)unlink(linkfile);

return ret;

{

bool success = false;

std::string lockfile;

lockfile.reserve(sock_name.size() + strlen(LOCKPOSTFIX));

lockfile = sock_name;

lockfile.append(LOCKPOSTFIX);

if (acquire_lock_file(lockfile, LOCKTIMEOUT, 1))

{

out_lockfile_name->swap(lockfile);

success = true;

}

return success;

{

// Cygwin has random problems involving sockets. When using Cygwin,

// allow 20 attempts at making socket correctly.

#ifdef __CYGWIN__

int attempts = 0;

repeat:

attempts += 1;

#endif

int s, len, doexit = 0;

int exitcode = EXIT_FAILURE;

struct sockaddr_un local;

const std::string sock_name = get_socket_filename();

/*

std::string lockfile;

if (! acquire_socket_lock(sock_name, &lockfile))

{

debug(0, L"Unable to obtain lock on socket, exiting");

exit(EXIT_FAILURE);

}

debug(4, L"Acquired lockfile: %s", lockfile.c_str());

local.sun_family = AF_UNIX;

strcpy(local.sun_path, sock_name.c_str());

len = sizeof(local);

debug(1, L"Connect to socket at %s", sock_name.c_str());

if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)

{

wperror(L"socket");

doexit = 1;

goto unlock;

}

/*

if (connect(s, (struct sockaddr *)&local, len) == 0)

{

debug(1, L"Socket already exists, exiting");

doexit = 1;

exitcode = 0;

goto unlock;

}

unlink(local.sun_path);

if (bind(s, (struct sockaddr *)&local, len) == -1)

{

wperror(L"bind");

doexit = 1;

goto unlock;

}

if (make_fd_nonblocking(s) != 0)

{

wperror(L"fcntl");

close(s);

doexit = 1;

}

else if (listen(s, 64) == -1)

{

wperror(L"listen");

doexit = 1;

}

unlock:

(void)unlink(lockfile.c_str());

debug(4, L"Released lockfile: %s", lockfile.c_str());

/*

if (doexit)

{

// If Cygwin, only allow normal quit when made lots of attempts.

#ifdef __CYGWIN__

if (exitcode && attempts < 20) goto repeat;

#endif

exit_without_destructors(exitcode);

}

return s;

{

message_t *msg;

if (connections.empty())

return;

msg = create_message(type, key, val);

/*

for (connection_list_t::iterator iter = connections.begin(); iter != connections.end(); ++iter)

{

msg->count++;

iter->unsent.push(msg);

}

for (connection_list_t::iterator iter = connections.begin(); iter != connections.end(); ++iter)

{

try_send_all(&*iter);

}

{

/*

switch (fork())

{

case -1:

debug(0, L"Could not put fishd in background. Quitting");

wperror(L"fork");

exit(1);

case 0:

{

/* Ordinarily there's very limited things we will do after fork, due to multithreading. But fishd is safe because it's single threaded. So don't die in is_forked_child. */

setup_fork_guards();

/*

struct sigaction act;

sigemptyset(& act.sa_mask);

act.sa_flags=0;

act.sa_handler=SIG_IGN;

sigaction(SIGHUP, &act, 0);

/*

sigfillset(& act.sa_mask);

act.sa_flags=0;

act.sa_handler=&handle_term;

sigaction(SIGTERM, &act, 0);

break;

}

default:

{

debug(0, L"Parent process exiting (This is normal)");

exit(0);

}

}

/*

setsid();

/*

close(0);

close(1);

{

const char *env = getenv(key);

if (env != NULL)

{

return env_var_t(str2wcstring(env));

}

else

{

const wcstring wkey = str2wcstring(key);

const wchar_t *tmp = env_universal_common_get(wkey);

return tmp ? env_var_t(tmp) : env_var_t::missing_var();

}

{

bool done = false;

wcstring result;

env_var_t xdg_dir = fishd_env_get("XDG_CONFIG_HOME");

if (! xdg_dir.missing_or_empty())

{

result = xdg_dir;

append_path_component(result, L"/fish");

if (!create_directory(result))

{

done = true;

}

}

else

{

env_var_t home = fishd_env_get("HOME");

if (! home.missing_or_empty())

{

result = home;

append_path_component(result, L"/.config/fish");

if (!create_directory(result))

{

done = 1;

}

}

}

if (! done)

{

/* Bad juju */

debug(0, _(L"Unable to create a configuration directory for fish. Your personal settings will not be saved. Please set the $XDG_CONFIG_HOME variable to a directory where the current user has write access."));

result.clear();

}

return result;

{

bool result = false;

debug(4, L"Open file for %s: '%s'",

save?"saving":"loading",

path.c_str());

/* OK to not use CLO_EXEC here because fishd is single threaded */

int fd = open(path.c_str(), save?(O_CREAT | O_TRUNC | O_WRONLY):O_RDONLY, 0600);

if (fd >= 0)

{

/* Success */

result = true;

connection_t c(fd);

if (save)

{

/* Save to the file */

write_loop(c.fd, SAVE_MSG, strlen(SAVE_MSG));

enqueue_all(&c);

}

else

{

/* Read from the file */

read_message(&c);

}

connection_destroy(&c);

}

return result;

{

std::string name;

name.append(dir);

name.append("/");

name.append(FILE);

name.append(identifier);

return name;

{

const wcstring wdir = fishd_get_config();

const std::string dir = wcs2string(wdir);

if (dir.empty())

return false;

const std::string machine_id = get_machine_identifier();

const std::string machine_id_path = get_variables_file_path(dir, machine_id);

bool success = load_or_save_variables_at_path(save, machine_id_path);

if (! success && ! save && errno == ENOENT)

{

/* We failed to load, because the file was not found. Older fish used the hostname only. Try *moving* the filename based on the hostname into place; if that succeeds try again. Silently "upgraded." */

std::string hostname_id;

if (get_hostname_identifier(&hostname_id) && hostname_id != machine_id)

{

std::string hostname_path = get_variables_file_path(dir, hostname_id);

if (0 == rename(hostname_path.c_str(), machine_id_path.c_str()))

{

/* We renamed - try again */

success = load_or_save_variables_at_path(save, machine_id_path);

}

}

}

return success;

{

sock = get_socket();

daemonize();

env_universal_common_init(&broadcast);

load();

{

int child_socket;

struct sockaddr_un remote;

socklen_t t;

int max_fd;

int update_count=0;

fd_set read_fd, write_fd;

set_main_thread();

setup_fork_guards();

program_name=L"fishd";

wsetlocale(LC_ALL, L"");

/*

while (1)

{

static struct option

long_options[] =

{

{

"help", no_argument, 0, 'h'

}

,

{

"version", no_argument, 0, 'v'

}

,

{

0, 0, 0, 0

}

}

;

int opt_index = 0;

int opt = getopt_long(argc,

argv,

GETOPT_STRING,

long_options,

&opt_index);

if (opt == -1)

break;

switch (opt)

{

case 0:

break;

case 'h':

print_help(argv[0], 1);

exit(0);

case 'v':

debug(0, L"%ls, version %s\n", program_name, FISH_BUILD_VERSION);

exit(0);

case '?':

return 1;

}

}

init();

while (1)

{

int res;

t = sizeof(remote);

FD_ZERO(&read_fd);

FD_ZERO(&write_fd);

FD_SET(sock, &read_fd);

max_fd = sock+1;

for (connection_list_t::const_iterator iter = connections.begin(); iter != connections.end(); ++iter)

{

const connection_t &c = *iter;

FD_SET(c.fd, &read_fd);

max_fd = maxi(max_fd, c.fd+1);

if (! c.unsent.empty())

{

FD_SET(c.fd, &write_fd);

}

}

while (1)

{

res=select(max_fd, &read_fd, &write_fd, 0, 0);

if (quit)

{

save();

exit(0);

}

if (res != -1)

break;

if (errno != EINTR)

{

wperror(L"select");

exit(1);

}

}

if (FD_ISSET(sock, &read_fd))

{

if ((child_socket =

accept(sock,

(struct sockaddr *)&remote,

&t)) == -1)

{

wperror(L"accept");

exit(1);

}

else

{