void
dnsdomainname (void)
{
char *host_name;
struct addrinfo hints, *res;
const char *dn;
int rc;
host_name = xgethostname ();
if (!host_name)
error (EXIT_FAILURE, errno, "cannot determine host name");
memset (&hints, 0, sizeof (struct addrinfo));
hints.ai_flags = AI_CANONNAME;
rc = getaddrinfo (host_name, NULL, &hints, &res);
if (rc != 0)
error (EXIT_FAILURE, 0, "%s", gai_strerror (rc));
dn = strchr (res->ai_canonname, '.');
if (dn)
puts (dn + 1);
free (host_name);
freeaddrinfo (res);
}
void create_server(t_server *serv)
{
int s;
int i;
struct sockaddr_in sin;
int nb_port;
memset(serv->fd_type, FD_FREE, MAX_FD * sizeof(int));
xgethostname(serv->hostname, MAX_HOST_NAME_LEN);
cfg_port(serv->port);
cfg_timeout(&(serv->timeout));
cfg_key(&(serv->key));
nb_port = count_nb_port(serv->port);
printf("*** IRC Server ***\n");
for (i = 0; i < nb_port; i++)
{
s = socket(PF_INET, SOCK_STREAM, 0);
sin.sin_family = AF_INET;
sin.sin_port = htons(serv->port[i]);
sin.sin_addr.s_addr = INADDR_ANY;
bind(s, (struct sockaddr *)&sin, sizeof(sin));
listen(s, MAX_LISTEN);
printf("Listen on port: %d\n", serv->port[i]);
serv->fd_type[s] = FD_SERVER;
serv->fct_read[s] = server_socket_read;
serv->fct_write[s] = 0;
}
serv->channel = 0;
}
CHECK_TYPE GLOBAL(PROGRAM_NAME_LOC)
{
char *hostname;
initialize_main (&argc, &argv);
set_program_name (argv[0]);
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
atexit (close_stdout);
parse_long_options (argc, argv, PROGRAM_NAME, PACKAGE_NAME, Version,
usage, AUTHORS, (char const *) NULL);
if (getopt_long (argc, argv, "", NULL, NULL) != -1)
usage (EXIT_FAILURE);
if (argc == optind + 1)
{
#ifdef HAVE_SETHOSTNAME
/* Set hostname to operand. */
char const *name = argv[optind];
if (sethostname (name, strlen (name)) != 0)
error (EXIT_FAILURE, errno, _("cannot set name to %s"), quote (name));
#else
error (EXIT_FAILURE, 0,
_("cannot set hostname; this system lacks the functionality"));
#endif
}
if (argc <= optind)
{
hostname = xgethostname ();
if (hostname == NULL)
error (EXIT_FAILURE, errno, _("cannot determine hostname"));
printf ("%s\n", hostname);
}
if (optind + 1 < argc)
{
error (0, 0, _("extra operand %s"), quote (argv[optind + 1]));
usage (EXIT_FAILURE);
}
exit (EXIT_SUCCESS);
return 0;
}
int
main (int argc, char *argv[])
{
char *hostname;
hostname = xgethostname ();
if (! hostname)
{
perror ("xgethostname");
return 1;
}
printf ("%s\n", hostname);
free (hostname);
return 0;
}
static const char *get_thishost(struct login_context *cxt, const char **domain)
{
if (!cxt->thishost) {
cxt->thishost = xgethostname();
if (!cxt->thishost) {
if (domain)
*domain = NULL;
return NULL;
}
cxt->thisdomain = strchr(cxt->thishost, '.');
if (cxt->thisdomain)
*cxt->thisdomain++ = '\0';
}
if (domain)
*domain = cxt->thisdomain;
return cxt->thishost;
}
/**
* shishi_keys_for_localservicerealm_in_file:
* @handle: Shishi library handle create by shishi_init().
* @filename: file to read keys from.
* @service: service to get key for.
* @realm: realm of server to get key for, or NULL for default realm.
*
* Get key for specified @service and @realm from @filename.
*
* Return value: Returns the key for the server
* "SERVICE/HOSTNAME@REALM" (where HOSTNAME is the current system's
* hostname), read from the default host keys file (see
* shishi_hostkeys_default_file()), or NULL if no key could be found
* or an error encountered.
**/
Shishi_key *
shishi_keys_for_localservicerealm_in_file (Shishi * handle,
const char *filename,
const char *service,
const char *realm)
{
char *hostname;
char *server;
Shishi_key *key;
hostname = xgethostname ();
asprintf (&server, "%s/%s", service, hostname);
key = shishi_keys_for_serverrealm_in_file (handle, filename, server, realm);
free (server);
free (hostname);
return key;
}
/*
main() -- make the program behave like sendmail, then call ssmtp
*/
int main(int argc, char **argv)
{
char **new_argv;
/* Try to be bulletproof :-) */
(void)signal(SIGHUP, SIG_IGN);
(void)signal(SIGINT, SIG_IGN);
(void)signal(SIGTTIN, SIG_IGN);
(void)signal(SIGTTOU, SIG_IGN);
/* Set the globals */
prog = basename(argv[0]);
hostname = xgethostname();
if(!hostname) {
perror("xgethostname");
die("Cannot get the name of this machine");
}
new_argv = parse_options(argc, argv);
exit(ssmtp(new_argv));
}
static inline char *logger_xgethostname(void)
{
char *str = getenv("LOGGER_TEST_HOSTNAME");
return str ? xstrdup(str) : xgethostname();
}
static char *makemsg(char *fname, char **mvec, int mvecsz,
size_t *mbufsize, int print_banner)
{
register int ch, cnt;
struct stat sbuf;
FILE *fp;
char *p, *lbuf, *tmpname, *mbuf;
long line_max;
line_max = sysconf(_SC_LINE_MAX);
lbuf = xmalloc(line_max);
if ((fp = xfmkstemp(&tmpname, NULL)) == NULL)
err(EXIT_FAILURE, _("can't open temporary file"));
unlink(tmpname);
free(tmpname);
if (print_banner == TRUE) {
char *hostname = xgethostname();
char *whom, *where, *date;
struct passwd *pw;
time_t now;
if (!(whom = getlogin()) || !*whom)
whom = (pw = getpwuid(getuid())) ? pw->pw_name : "???";
if (!whom) {
whom = "someone";
warn(_("cannot get passwd uid"));
}
where = ttyname(STDOUT_FILENO);
if (!where) {
where = "somewhere";
warn(_("cannot get tty name"));
} else if (strncmp(where, "/dev/", 5) == 0)
where += 5;
time(&now);
date = xstrdup(ctime(&now));
date[strlen(date) - 1] = '\0';
/*
* all this stuff is to blank out a square for the message;
* we wrap message lines at column 79, not 80, because some
* terminals wrap after 79, some do not, and we can't tell.
* Which means that we may leave a non-blank character
* in column 80, but that can't be helped.
*/
/* snprintf is not always available, but the sprintf's here
will not overflow as long as %d takes at most 100 chars */
fprintf(fp, "\r%79s\r\n", " ");
sprintf(lbuf, _("Broadcast message from %s@%s (%s) (%s):"),
whom, hostname, where, date);
fprintf(fp, "%-79.79s\007\007\r\n", lbuf);
free(hostname);
free(date);
}
fprintf(fp, "%79s\r\n", " ");
if (mvec) {
/*
* Read message from argv[]
*/
int i;
for (i = 0; i < mvecsz; i++) {
fputs(mvec[i], fp);
if (i < mvecsz - 1)
fputc(' ', fp);
}
fputc('\r', fp);
fputc('\n', fp);
} else {
/*
* read message from <file>
*/
if (fname) {
/*
* When we are not root, but suid or sgid, refuse to read files
* (e.g. device files) that the user may not have access to.
* After all, our invoker can easily do "wall < file"
* instead of "wall file".
*/
uid_t uid = getuid();
if (uid && (uid != geteuid() || getgid() != getegid()))
errx(EXIT_FAILURE, _("will not read %s - use stdin."),
fname);
if (!freopen(fname, "r", stdin))
err(EXIT_FAILURE, _("cannot open %s"), fname);
}
/*
* Read message from stdin.
*/
while (fgets(lbuf, line_max, stdin)) {
for (cnt = 0, p = lbuf; (ch = *p) != '\0'; ++p, ++cnt) {
if (cnt == 79 || ch == '\n') {
for (; cnt < 79; ++cnt)
putc(' ', fp);
putc('\r', fp);
putc('\n', fp);
cnt = 0;
}
if (ch != '\n')
carefulputc(ch, fp);
}
}
}
fprintf(fp, "%79s\r\n", " ");
free(lbuf);
rewind(fp);
if (fstat(fileno(fp), &sbuf))
err(EXIT_FAILURE, _("stat failed"));
*mbufsize = (size_t) sbuf.st_size;
mbuf = xmalloc(*mbufsize);
if (fread(mbuf, 1, *mbufsize, fp) != *mbufsize)
err(EXIT_FAILURE, _("fread failed"));
if (close_stream(fp) != 0)
errx(EXIT_FAILURE, _("write error"));
return mbuf;
}
static int get_pack(struct fetch_pack_args *args,
int xd[2], char **pack_lockfile)
{
struct async demux;
int do_keep = args->keep_pack;
const char *cmd_name;
struct pack_header header;
int pass_header = 0;
struct child_process cmd = CHILD_PROCESS_INIT;
int ret;
memset(&demux, 0, sizeof(demux));
if (use_sideband) {
/* xd[] is talking with upload-pack; subprocess reads from
* xd[0], spits out band#2 to stderr, and feeds us band#1
* through demux->out.
*/
demux.proc = sideband_demux;
demux.data = xd;
demux.out = -1;
demux.isolate_sigpipe = 1;
if (start_async(&demux))
die(_("fetch-pack: unable to fork off sideband demultiplexer"));
}
else
demux.out = xd[0];
if (!args->keep_pack && unpack_limit) {
if (read_pack_header(demux.out, &header))
die(_("protocol error: bad pack header"));
pass_header = 1;
if (ntohl(header.hdr_entries) < unpack_limit)
do_keep = 0;
else
do_keep = 1;
}
if (alternate_shallow_file) {
argv_array_push(&cmd.args, "--shallow-file");
argv_array_push(&cmd.args, alternate_shallow_file);
}
if (do_keep || args->from_promisor) {
if (pack_lockfile)
cmd.out = -1;
cmd_name = "index-pack";
argv_array_push(&cmd.args, cmd_name);
argv_array_push(&cmd.args, "--stdin");
if (!args->quiet && !args->no_progress)
argv_array_push(&cmd.args, "-v");
if (args->use_thin_pack)
argv_array_push(&cmd.args, "--fix-thin");
if (do_keep && (args->lock_pack || unpack_limit)) {
char hostname[HOST_NAME_MAX + 1];
if (xgethostname(hostname, sizeof(hostname)))
xsnprintf(hostname, sizeof(hostname), "localhost");
argv_array_pushf(&cmd.args,
"--keep=fetch-pack %"PRIuMAX " on %s",
(uintmax_t)getpid(), hostname);
}
if (args->check_self_contained_and_connected)
argv_array_push(&cmd.args, "--check-self-contained-and-connected");
if (args->from_promisor)
argv_array_push(&cmd.args, "--promisor");
}
else {
cmd_name = "unpack-objects";
argv_array_push(&cmd.args, cmd_name);
if (args->quiet || args->no_progress)
argv_array_push(&cmd.args, "-q");
args->check_self_contained_and_connected = 0;
}
if (pass_header)
argv_array_pushf(&cmd.args, "--pack_header=%"PRIu32",%"PRIu32,
ntohl(header.hdr_version),
ntohl(header.hdr_entries));
if (fetch_fsck_objects >= 0
? fetch_fsck_objects
: transfer_fsck_objects >= 0
? transfer_fsck_objects
: 0) {
if (args->from_promisor)
/*
* We cannot use --strict in index-pack because it
* checks both broken objects and links, but we only
* want to check for broken objects.
*/
argv_array_push(&cmd.args, "--fsck-objects");
else
argv_array_pushf(&cmd.args, "--strict%s",
fsck_msg_types.buf);
}
cmd.in = demux.out;
cmd.git_cmd = 1;
if (start_command(&cmd))
die(_("fetch-pack: unable to fork off %s"), cmd_name);
if (do_keep && pack_lockfile) {
*pack_lockfile = index_pack_lockfile(cmd.out);
close(cmd.out);
}
if (!use_sideband)
/* Closed by start_command() */
xd[0] = -1;
ret = finish_command(&cmd);
if (!ret || (args->check_self_contained_and_connected && ret == 1))
args->self_contained_and_connected =
args->check_self_contained_and_connected &&
ret == 0;
else
die(_("%s failed"), cmd_name);
if (use_sideband && finish_async(&demux))
die(_("error in sideband demultiplexer"));
return 0;
}
/* return NULL on success, else hostname running the gc */
static const char *lock_repo_for_gc(int force, pid_t* ret_pid)
{
struct lock_file lock = LOCK_INIT;
char my_host[HOST_NAME_MAX + 1];
struct strbuf sb = STRBUF_INIT;
struct stat st;
uintmax_t pid;
FILE *fp;
int fd;
char *pidfile_path;
if (is_tempfile_active(pidfile))
/* already locked */
return NULL;
if (xgethostname(my_host, sizeof(my_host)))
xsnprintf(my_host, sizeof(my_host), "unknown");
pidfile_path = git_pathdup("gc.pid");
fd = hold_lock_file_for_update(&lock, pidfile_path,
LOCK_DIE_ON_ERROR);
if (!force) {
static char locking_host[HOST_NAME_MAX + 1];
static char *scan_fmt;
int should_exit;
if (!scan_fmt)
scan_fmt = xstrfmt("%s %%%ds", "%"SCNuMAX, HOST_NAME_MAX);
fp = fopen(pidfile_path, "r");
memset(locking_host, 0, sizeof(locking_host));
should_exit =
fp != NULL &&
!fstat(fileno(fp), &st) &&
/*
* 12 hour limit is very generous as gc should
* never take that long. On the other hand we
* don't really need a strict limit here,
* running gc --auto one day late is not a big
* problem. --force can be used in manual gc
* after the user verifies that no gc is
* running.
*/
time(NULL) - st.st_mtime <= 12 * 3600 &&
fscanf(fp, scan_fmt, &pid, locking_host) == 2 &&
/* be gentle to concurrent "gc" on remote hosts */
(strcmp(locking_host, my_host) || !kill(pid, 0) || errno == EPERM);
if (fp != NULL)
fclose(fp);
if (should_exit) {
if (fd >= 0)
rollback_lock_file(&lock);
*ret_pid = pid;
free(pidfile_path);
return locking_host;
}
}
strbuf_addf(&sb, "%"PRIuMAX" %s",
(uintmax_t) getpid(), my_host);
write_in_full(fd, sb.buf, sb.len);
strbuf_release(&sb);
commit_lock_file(&lock);
pidfile = register_tempfile(pidfile_path);
free(pidfile_path);
return NULL;
}
static void syslog_rfc5424(const struct logger_ctl *ctl, const char *msg)
{
char *buf, *tag = NULL, *hostname = NULL;
char pid[32], time[64], timeq[80];
struct ntptimeval ntptv;
struct timeval tv;
struct tm *tm;
int len;
*pid = *time = *timeq = '\0';
if (ctl->fd < 0)
return;
if (ctl->rfc5424_time) {
gettimeofday(&tv, NULL);
if ((tm = localtime(&tv.tv_sec)) != NULL) {
char fmt[64];
strftime(fmt, sizeof(fmt), " %Y-%m-%dT%H:%M:%S.%%06u%z",
tm);
snprintf(time, sizeof(time), fmt, tv.tv_usec);
} else
err(EXIT_FAILURE, _("localtime() failed"));
}
if (ctl->rfc5424_host) {
hostname = xgethostname();
/* Arbitrary looking 'if (var < strlen()) checks originate from
* RFC 5424 - 6 Syslog Message Format definition. */
if (255 < strlen(hostname))
errx(EXIT_FAILURE, _("hostname '%s' is too long"),
hostname);
}
tag = ctl->tag ? ctl->tag : xgetlogin();
if (48 < strlen(tag))
errx(EXIT_FAILURE, _("tag '%s' is too long"), tag);
if (ctl->pid)
snprintf(pid, sizeof(pid), " %d", ctl->pid);
if (ctl->rfc5424_tq) {
if (ntp_gettime(&ntptv) == TIME_OK)
snprintf(timeq, sizeof(timeq),
" [timeQuality tzKnown=\"1\" isSynced=\"1\" syncAccuracy=\"%ld\"]",
ntptv.maxerror);
else
snprintf(timeq, sizeof(timeq),
" [timeQuality tzKnown=\"1\" isSynced=\"0\"]");
}
len = xasprintf(&buf, "<%d>1%s%s%s %s -%s%s %s", ctl->pri, time,
hostname ? " " : "",
hostname ? hostname : "",
tag, pid, timeq, msg);
if (write_all(ctl->fd, buf, len) < 0)
warn(_("write failed"));
if (ctl->stderr_printout)
fprintf(stderr, "%s\n", buf);
free(hostname);
free(buf);
}
