void do_sethostname(char *s, int isfile) { FILE *f; char buf[255]; if (!s) return; if (!isfile) { if (sethostname(s, strlen(s)) < 0) { if (errno == EPERM) { printf("%% you must be root to change the hostname\n"); return; } else { printf("%% error sethostname\r\n"); return; } } } else { f = xfopen(s, "r"); fgets(buf, 255, f); fclose(f); if (buf[strlen(buf) - 1] == '\n') buf[strlen(buf) - 1] = 0; if (sethostname(buf, strlen(buf)) < 0) { printf("%% error sethostname\n"); return; } } }
ATF_TC_BODY(sethostname_perm, tc) { errno = 0; ATF_REQUIRE_ERRNO(EPERM, sethostname(host, sizeof(host)) == -1); }
int child_main(void* arg) { char c; // init sync primitive close(checkpoint[1]); // setup hostname printf(" - [%5d] World !\n", getpid()); sethostname("In Namespace", 12); // remount "/proc" to get accurate "top" && "ps" output chdir("root/"); int chroot_err = chroot("."); if (chroot_err != 0) { printf("chroot error\n"); } mount("proc", "/proc", "proc", 0, NULL); chdir("/bin"); setuid(0); setgid(0); // wait... read(checkpoint[0], &c, 1); execv(child_args[0], child_args); printf("Ooops\n"); printf("result %d\n", errno); return 1; }
int hyper_start_containers(struct hyper_pod *pod) { int i; /* mount new proc directory */ if (umount("/proc") < 0) { perror("umount proc filesystem failed\n"); return -1; } if (mount("proc", "/proc", "proc", 0, NULL) < 0) { perror("mount proc filesystem failed\n"); return -1; } if (sethostname(pod->hostname, strlen(pod->hostname)) < 0) { perror("set host name failed"); return -1; } for (i = 0; i < pod->c_num; i++) hyper_start_container(&pod->c[i]); return 0; }
int main() { const char * old_domain_name = get_domain_name(); const char * old_host_name = get_host_name(); step("parent: old domainname: %s", old_domain_name); step("parent: old hostname: %s", old_host_name); step("parent: fork"); if (fork()) { step("parent: wait for child to exit"); int status = 0; do wait(&status); while (!WIFEXITED(status)); assertStrEquals("parent: domain name", old_domain_name, get_domain_name()); assertStrEquals("parent: host name", old_host_name, get_host_name()); } else { step("child: create container with separate uts namespace"); struct slc_create_container_parameters params; initialize_default_fs_root(¶ms.fs_root); slc_create_container(¶ms, 0); const char * new_domain_name = "new_domain_name"; const char * new_host_name = "new_host_name"; step("child: set domain name to '%s'", new_domain_name); setdomainname(new_domain_name, strlen(new_domain_name)); assertStrEquals("child: domain name", new_domain_name, get_domain_name()); step("child: set host name to '%s'", new_host_name); sethostname(new_host_name, strlen(new_host_name)); assertStrEquals("child: host name", new_host_name, get_host_name()); } return 0; }
TError SetHostName(const std::string &name) { int ret = sethostname(name.c_str(), name.length()); if (ret < 0) return TError(EError::Unknown, errno, "sethostname(" + name + ")"); return TError::Success(); }
int child_main(void* arg) { char c; // init sync primitive close(checkpoint[1]); // setup hostname printf(" - [%5d] World !\n", getpid()); sethostname("In Namespace", 12); // remount "/proc" to get accurate "top" && "ps" output mount("proc", "/proc", "proc", 0, NULL); // wait for network setup in parent read(checkpoint[0], &c, 1); // setup network system("ip link set lo up"); system("ip link set veth1 up"); system("ip addr add 169.254.1.2/30 dev veth1"); execv(child_args[0], child_args); printf("Ooops\n"); return 1; }
static int context_update_kernel_hostname(Context *c) { const char *static_hn; const char *hn; assert(c); static_hn = c->data[PROP_STATIC_HOSTNAME]; /* /etc/hostname with something other than "localhost" * has the highest preference ... */ if (hostname_is_useful(static_hn)) hn = static_hn; /* ... the transient host name, (ie: DHCP) comes next ...*/ else if (!isempty(c->data[PROP_HOSTNAME])) hn = c->data[PROP_HOSTNAME]; /* ... fallback to static "localhost.*" ignored above ... */ else if (!isempty(static_hn)) hn = static_hn; /* ... and the ultimate fallback */ else hn = "localhost"; if (sethostname(hn, strlen(hn)) < 0) return -errno; return 0; }
static int loopback_set_hostname(const char *hostname) { const char *ptr; int err, len; if (g_strcmp0(hostname, "<hostname>") == 0) return 0; len = strlen(hostname); if (connman_inet_check_hostname(hostname, len) == FALSE) return -EINVAL; if ((ptr = strstr(hostname, ".")) != NULL) len = ptr - hostname; if (sethostname(hostname, len) < 0) { err = -errno; connman_error("Failed to set hostname to %s", hostname); return err; } connman_info("Setting hostname to %s", hostname); return 0; }
int command_hostname (int argc, char **argv) { char hostname[MAXHOSTNAMELEN]; progname = argv[0]; if (argc == 1) { if (gethostname (hostname, MAXHOSTNAMELEN) < 0) error ("cannot get hostname: %s", strerror (errno)); puts (hostname); return (EXIT_SUCCESS); } else if (argc == 2) { if (!strcmp (argv[1], "--help")) puts (help_text); else if (!strcmp (argv[1], "--version")) puts ("hostname: version "VERSION); else { if (sethostname (argv[1], strlen (argv[1])) < 0) error ("cannot set hostname: %s", strerror (errno)); } } else terror ("too many arguments"); return (EXIT_SUCCESS); }
/* * cleanup() - performs all one time cleanup for this test * completion or premature exit. */ void cleanup() { int ret; /* * print timing stats if that option was specified. * print errno log if that option was specified. */ TEST_CLEANUP; /* Set effective user id back to root/super user */ if (seteuid(0) == -1) { tst_resm(TWARN, "seteuid failed to " "to set the effective uid to root" ); perror("seteuid"); } /* Restore host name */ if( (ret = sethostname (hname, strlen(hname))) < 0 ) { tst_resm(TWARN, "sethostname() failed while restoring" " hostname to \"%s\"", hname); } /* exit with return code appropriate for results */ tst_exit(); }
ATF_TC_BODY(sethostname_basic, tc) { char name[MAXHOSTNAMELEN]; size_t i; for (i = 0; i < __arraycount(hosts); i++) { (void)memset(name, 0, sizeof(name)); ATF_REQUIRE(sethostname(hosts[i], sizeof(hosts[i])) == 0); ATF_REQUIRE(gethostname(name, sizeof(name)) == 0); ATF_REQUIRE(strcmp(hosts[i], name) == 0); } (void)sethostname(host, sizeof(host)); }
static int uwsgi_hook_hostname(char *arg) { #ifdef __CYGWIN__ return -1; #else return sethostname(arg, strlen(arg)); #endif }
int container_main(void * arg) { printf("Container - inside the container!\n"); sethostname("container",10); /* 设置hostname */ execv(container_args[0], container_args); printf("Something's wrong\n"); return 1; }
gboolean nm_policy_set_system_hostname (const char *new_hostname, const char *msg) { char old_hostname[HOST_NAME_MAX + 1]; const char *name; int ret; if (new_hostname) g_warn_if_fail (strlen (new_hostname)); old_hostname[HOST_NAME_MAX] = '\0'; errno = 0; ret = gethostname (old_hostname, HOST_NAME_MAX); if (ret != 0) { nm_log_warn (LOGD_DNS, "couldn't get the system hostname: (%d) %s", errno, strerror (errno)); } else { /* Don't set the hostname if it isn't actually changing */ if ( (new_hostname && !strcmp (old_hostname, new_hostname)) || (!new_hostname && !strcmp (old_hostname, FALLBACK_HOSTNAME4))) return FALSE; } name = (new_hostname && strlen (new_hostname)) ? new_hostname : FALLBACK_HOSTNAME4; nm_log_info (LOGD_DNS, "Setting system hostname to '%s' (%s)", name, msg); ret = sethostname (name, strlen (name)); if (ret != 0) { nm_log_warn (LOGD_DNS, "couldn't set the system hostname to '%s': (%d) %s", name, errno, strerror (errno)); } return (ret == 0); }
TEST(UNISTD_TEST, sethostname) { // The permissions check happens before the argument check, so this will // fail for a different reason if you're running as root than if you're // not, but it'll fail either way. Checking that we have the symbol is about // all we can do for sethostname(2). ASSERT_EQ(-1, sethostname("", -1)); }
int main(int ac, char **av) { int lc; tst_parse_opts(ac, av, NULL, NULL); /* Do initial setup */ setup(); /* Check for looping state if -i option is given */ for (lc = 0; TEST_LOOPING(lc); lc++) { tst_count = 0; /* call sethostname() */ TEST(sethostname(ltpthost, sizeof(ltpthost))); if ((TEST_RETURN == -1) && (TEST_ERRNO == EPERM)) { tst_resm(TPASS, "Expected Failure; Got EPERM"); } else { tst_resm(TFAIL, "call failed to produce " "expected error; errno: %d : %s", TEST_ERRNO, strerror(TEST_ERRNO)); } } /* cleanup and exit */ cleanup(); tst_exit(); }
static PyObject *_agentlib_sethostname(PyObject *self, PyObject *args) { char *host_string; int err; size_t host_len; if (!PyArg_ParseTuple(args, "s", &host_string)) { return NULL; } host_len = strlen(host_string); if (host_len > 63) host_len = 63; err = sethostname(host_string, host_len); if (err < 0) { err = errno; return PyErr_Format(PyExc_SystemError, "sethostname() failed with errno '%d'", err); } Py_RETURN_NONE; }
static void do_sethostname(char *s, int isfile) { FILE *f; char buf[255]; if (!s) return; if (!isfile) { if (sethostname(s, strlen(s)) < 0) { if (errno == EPERM) bb_error_msg_and_die("you must be root to change the hostname"); else bb_perror_msg_and_die("sethostname"); } } else { f = bb_xfopen(s, "r"); while (fgets(buf, 255, f) != NULL) { if (buf[0] =='#') { continue; } chomp(buf); do_sethostname(buf, 0); } #ifdef CONFIG_FEATURE_CLEAN_UP fclose(f); #endif } }
static int childFunc(void *arg) { struct utsname uts; sethostname(arg, strlen(arg)); /* Change hostname in UTS namespace of child */ uname(&uts); /* Retrieve hostname - uses an output parameter */ printf("uts.nodename in child: %s\n", uts.nodename); return 0; }
int main(int argc, char *argv[]) { if(argc != 2) { printf("Use : %s [ hostname ]\n", argv[0]); return 0; } struct utsname uts; int pid = fork(); if(pid == 0) { unshare(CLONE_NEWUTS); if(sethostname(argv[1], strlen(argv[1])) != 0) { printf("sethostname() failed\n"); return 0; } uname(&uts); printf("Child hostname : %s\n", uts.nodename); return 0; } uname(&uts); printf("Parent hostname : %s\n", uts.nodename); return 0; }
static void test_main(void) { const char name[] = "foobarserver"; int rv; mStatus status; rv = sethostname(&name[0], sizeof(name) - 1); assert(rv == 0); status = mDNS_Init(&mDNSStorage, &PlatformStorage, mDNS_Init_NoCache, mDNS_Init_ZeroCacheSize, mDNS_Init_AdvertiseLocalAddresses, mDNS_Init_NoInitCallback, mDNS_Init_NoInitCallbackContext); assert(status == mStatus_NoError); foobar_create_thread(); while (1) { struct timeval timeout = { .tv_sec = 0x3fffffff, .tv_usec = 0 }; sigset_t signals; mDNSBool got_something; mDNSPosixRunEventLoopOnce(&mDNSStorage, &timeout, &signals, &got_something); } }
int main(int argc, char *argv[]) { int ch, sflag; char *p, hostname[MAXHOSTNAMELEN]; sflag = 0; while ((ch = getopt(argc, argv, "s")) != -1) switch (ch) { case 's': sflag = 1; break; default: usage(); } argc -= optind; argv += optind; if (argc > 1) usage(); if (*argv) { if (sethostname(*argv, strlen(*argv))) err(1, "sethostname"); } else { if (gethostname(hostname, sizeof(hostname))) err(1, "gethostname"); if (sflag && (p = strchr(hostname, '.'))) *p = '\0'; (void)printf("%s\n", hostname); } exit(0); }
static int do_start(void *arg) { struct start_arg *start_arg = arg; char **args = *start_arg->args; int flags = *start_arg->flags; uid_t uid = *start_arg->uid; int want_default_mounts = start_arg->want_default_mounts; const char *want_hostname = start_arg->want_hostname; if ((flags & CLONE_NEWNS) && want_default_mounts) lxc_setup_fs(); if ((flags & CLONE_NEWUTS) && want_hostname) if (sethostname(want_hostname, strlen(want_hostname)) < 0) { ERROR("failed to set hostname %s: %s", want_hostname, strerror(errno)); exit(1); } // Setuid is useful even without a new user id space if (start_arg->setuid && setuid(uid)) { ERROR("failed to set uid %d: %s", uid, strerror(errno)); exit(1); } execvp(args[0], args); ERROR("failed to exec: '%s': %s", args[0], strerror(errno)); return 1; }
/* * Actually setup our network interface with the values derived from the * PROM, DHCP or interactively from the user. */ static void setup_interface() { char str[MAXHOSTNAMELEN]; /* will accomodate an IP too */ size_t len; struct in_addr in_addr; len = sizeof (str); if (bootinfo_get(BI_HOST_IP, str, &len, NULL) == BI_E_SUCCESS && (in_addr.s_addr = inet_addr(str)) != (in_addr_t)-1) { in_addr.s_addr = htonl(in_addr.s_addr); ipv4_setipaddr(&in_addr); } len = sizeof (str); if (bootinfo_get(BI_SUBNET_MASK, str, &len, NULL) == BI_E_SUCCESS && (in_addr.s_addr = inet_addr(str)) != (in_addr_t)-1) { in_addr.s_addr = htonl(in_addr.s_addr); ipv4_setnetmask(&in_addr); } len = sizeof (str); if (bootinfo_get(BI_ROUTER_IP, str, &len, NULL) == BI_E_SUCCESS && (in_addr.s_addr = inet_addr(str)) != (in_addr_t)-1) { in_addr.s_addr = htonl(in_addr.s_addr); ipv4_setdefaultrouter(&in_addr); (void) ipv4_route(IPV4_ADD_ROUTE, RT_DEFAULT, NULL, &in_addr); } len = sizeof (str); if (bootinfo_get(BI_HOSTNAME, str, &len, NULL) == BI_E_SUCCESS) { (void) sethostname(str, len); } }
int child_main(void *args) { printf("in child process \n"); sethostname("NewNameSpace", 20); execv(child_args[0], child_args); return 1; }
int child_main(void* arg) { printf(" - World !\n"); sethostname("In Namespace", 12); execv(child_args[0], child_args); printf("Oops\n"); return 1; }
// Returns a `Try` of the result of attempting to set the `hostname`. inline Try<Nothing> setHostname(const std::string& hostname) { if (sethostname(hostname.c_str(), hostname.size()) != 0) { return ErrnoError(); } return Nothing(); }
/** * Change hostname */ void setup_hostname(const char *name) { if (!name) return; if (sethostname(name, strlen(name)) == -1) { SYSERROR("can`t set hostname"); throw -1; } }
ATF_TC_BODY(sethostname_limit, tc) { char name[MAXHOSTNAMELEN + 1]; (void)memset(name, 0, sizeof(name)); ATF_REQUIRE(sethostname(name, sizeof(name)) == -1); }