Esempio n. 1
0
int
VTCP_connect(const struct suckaddr *name, int msec)
{
	int s, i;
	struct pollfd fds[1];
	const struct sockaddr *sa;
	socklen_t sl;
	int val;

	if (name == NULL)
		return (-1);
	/* Attempt the connect */
	AN(VSA_Sane(name));
	sa = VSA_Get_Sockaddr(name, &sl);
	AN(sa);
	AN(sl);

	s = socket(sa->sa_family, SOCK_STREAM, 0);
	if (s < 0)
		return (s);

	/* Set the socket non-blocking */
	if (msec != 0)
		(void)VTCP_nonblocking(s);

	val = 1;
	AZ(setsockopt(s, IPPROTO_TCP, TCP_NODELAY, &val, sizeof val));

	i = connect(s, sa, sl);
	if (i == 0)
		return (s);
	if (errno != EINPROGRESS) {
		closefd(&s);
		return (-1);
	}

	if (msec < 0) {
		/*
		 * Caller is responsible for waiting and
		 * calling VTCP_connected
		 */
		return (s);
	}

	assert(msec > 0);
	/* Exercise our patience, polling for write */
	fds[0].fd = s;
	fds[0].events = POLLWRNORM;
	fds[0].revents = 0;
	i = poll(fds, 1, msec);

	if (i == 0) {
		/* Timeout, close and give up */
		closefd(&s);
		errno = ETIMEDOUT;
		return (-1);
	}

	return (VTCP_connected(s));
}
int catgrepmore(char *fname, int fds1[2], int fds2[2]) {
  int ifd, grep_status, more_status;
   /* This is essentially how the pipes are set up:
            --------------      -------------
      parent     PIPE1     grep     PIPE2    more
            --------------      -------------
            ^            ^      ^           ^
          Write         Read  Write        Read
  */
  //CHILD: grep
  pid_t grep_pid = fork();         
  if(grep_pid == -1) { perror("fork"); exit(1); }
  if(grep_pid == 0) {
    closefd(fds1[WRITE_END]);            /* close write end of pipe1 */            
    closefd(fds2[READ_END]);             /* close read end of pipe2 */  
    redirect(fds1[READ_END], STDIN);     /* redirect stdin to read end of pipe1, then close read end */ 
    redirect(fds2[WRITE_END], STDOUT);   /* redirect stdout to write end of pipe2, then close write end */
    execlp("grep", "grep", pattern, (char *) NULL);
    perror("execlp: grep");
    exit(1);
  }
  
  pid_t more_pid = fork();
  if(more_pid == -1) { perror("fork"); exit(1); }
  //CHILD: more
  if(more_pid == 0) {
    closefd(fds1[WRITE_END]);            /* close write end of pipe1 */
    closefd(fds1[READ_END]);             /* close read end of pipe1 */
    closefd(fds2[WRITE_END]);            /* close write end of pipe2 */
    redirect(fds2[READ_END], STDIN);     /* redirect stdin to read end of pipe2, then close read end */
    execlp("more", "more", (char *) NULL);
    perror("execlp: more");
    exit(1);
  }
 
  //PARENT
  if(grep_pid != 0 && more_pid != 0) {
    if((ifd = open(fname, O_RDONLY, 0666)) == -1) {
      fprintf(stderr, "open: Can't open %s for reading: %s\n", fname, strerror(errno));
      exit(1);
    }
    closefd(fds1[READ_END]);              /* close read end of pipe1 */
    closefd(fds2[WRITE_END]);             /* close write end of pipe2 */
    closefd(fds2[READ_END]);              /* close read end of pipe2 */
    readwrite(ifd, fds1[WRITE_END]);      /* fill read end of pipe1 with data from infile */
    closefd(fds1[WRITE_END]);             /* close write end of pipe1 cuz we're done with it */
    closefd(ifd);                         /* close input fd cuz we're done with it */
    grep_pid = waitpid(grep_pid, &grep_status, 0); 
    more_pid = waitpid(more_pid, &more_status, 0);
    pchildstatus(grep_pid, grep_status, "grep"); /* report exit status of grep */
    pchildstatus(more_pid, more_status, "more"); /* report exit status of more */
  }

  return 0;
}
Esempio n. 3
0
int
VTCP_bind(const struct suckaddr *sa, const char **errp)
{
	int sd, val, e;
	socklen_t sl;
	const struct sockaddr *so;
	int proto;

	if (errp != NULL)
		*errp = NULL;

	proto = VSA_Get_Proto(sa);
	sd = socket(proto, SOCK_STREAM, 0);
	if (sd < 0) {
		if (errp != NULL)
			*errp = "socket(2)";
		return (-1);
	}
	val = 1;
	if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof val) != 0) {
		if (errp != NULL)
			*errp = "setsockopt(SO_REUSEADDR, 1)";
		e = errno;
		closefd(&sd);
		errno = e;
		return (-1);
	}
#ifdef IPV6_V6ONLY
	/* forcibly use separate sockets for IPv4 and IPv6 */
	val = 1;
	if (proto == AF_INET6 &&
	    setsockopt(sd, IPPROTO_IPV6, IPV6_V6ONLY, &val, sizeof val) != 0) {
		if (errp != NULL)
			*errp = "setsockopt(IPV6_V6ONLY, 1)";
		e = errno;
		closefd(&sd);
		errno = e;
		return (-1);
	}
#endif
	so = VSA_Get_Sockaddr(sa, &sl);
	if (bind(sd, so, sl) != 0) {
		if (errp != NULL)
			*errp = "bind(2)";
		e = errno;
		closefd(&sd);
		errno = e;
		return (-1);
	}
	return (sd);
}
Esempio n. 4
0
int
VPF_Read(const char *path, pid_t *pidptr)
{
	char buf[16], *endptr;
	int error, fd, i;

	fd = open(path, O_RDONLY | O_CLOEXEC);
	if (fd == -1)
		return (errno);

	i = read(fd, buf, sizeof(buf) - 1);
	error = errno;
	closefd(&fd);
	if (i == -1)
		return (error);
	else if (i == 0)
		return (EAGAIN);
	if (i > 0 && buf[i - 1] == '\n')
		i--;
	buf[i] = '\0';

	*pidptr = strtol(buf, &endptr, 10);
	if (endptr != &buf[i])
		return (EINVAL);

	return (0);
}
Esempio n. 5
0
/*
 * Wrapper for dup2 - same semantics as dup2 system call except
 * that any threads blocked in an I/O system call on fd2 will be
 * preempted and return -1/EBADF;
 */
int NET_Dup2(int fd, int fd2) {
    if (fd < 0) {
        errno = EBADF;
        return -1;
    }
    return closefd(fd, fd2);
}
Esempio n. 6
0
void
mgt_cli_secret(const char *S_arg)
{
	int i, fd;
	char buf[BUFSIZ];

	/* Save in shmem */
	mgt_SHM_static_alloc(S_arg, strlen(S_arg) + 1L, "Arg", "-S");

	VJ_master(JAIL_MASTER_FILE);
	fd = open(S_arg, O_RDONLY);
	if (fd < 0) {
		fprintf(stderr, "Can not open secret-file \"%s\"\n", S_arg);
		exit(2);
	}
	VJ_master(JAIL_MASTER_LOW);
	MCH_TrackHighFd(fd);
	i = read(fd, buf, sizeof buf);
	if (i == 0) {
		fprintf(stderr, "Empty secret-file \"%s\"\n", S_arg);
		exit(2);
	}
	if (i < 0) {
		fprintf(stderr, "Can not read secret-file \"%s\"\n", S_arg);
		exit(2);
	}
	closefd(&fd);
	secret_file = S_arg;
}
Esempio n. 7
0
int
VJ_make_workdir(const char *dname)
{
	int fd;

	AN(dname);
	CHECK_OBJ_NOTNULL(vjt, JAIL_TECH_MAGIC);
	if (vjt->make_workdir != NULL)
		return (vjt->make_workdir(dname));

	VJ_master(JAIL_MASTER_FILE);
	if (mkdir(dname, 0755) < 0 && errno != EEXIST)
		ARGV_ERR("Cannot create working directory '%s': %s\n",
		    dname, strerror(errno));

	if (chdir(dname) < 0)
		ARGV_ERR("Cannot change to working directory '%s': %s\n",
		    dname, strerror(errno));

	fd = open("_.testfile", O_RDWR|O_CREAT|O_EXCL, 0600);
	if (fd < 0)
		ARGV_ERR("Cannot create test-file in %s (%s)\n"
		    "Check permissions (or delete old directory)\n",
		    dname, strerror(errno));
	closefd(&fd);
	AZ(unlink("_.testfile"));
	VJ_master(JAIL_MASTER_LOW);
	return (0);
}
Esempio n. 8
0
void PukeController::Traffic(int fd) /*FOLD00*/
{
  PukeMessage pm;
  int bytes = -1;
  memset(&pm, 0, sizeof(pm));
  while((bytes = read(fd, &pm, 5*sizeof(int))) > 0){
    if(bytes != 5*sizeof(int)){
      cerr << "Short message, Got: " << bytes << " Wanted: " << sizeof(PukeMessage) << " NULL Padded" << endl;
    }
#ifdef DEBUG
    printf("Traffic on: %d => %d %d %d %d",
           fd,
	   pm.iCommand, 
	   pm.iWinId,
	   pm.iArg,
           pm.iTextSize);
    if(pm.iCommand == 0x0){
      abort();
    }
#endif /* DEBUG */
    if(pm.iHeader != iPukeHeader){
      warning("Invalid packet received, discarding!");
      return;
    }
    if(pm.iTextSize > 0){
      pm.cArg = new char[pm.iTextSize + 1];
      read(fd, pm.cArg, pm.iTextSize * sizeof(char));
      pm.cArg[pm.iTextSize] = 0x0; // Null terminate the string.
//      printf(" %s\n", pm.cArg);
    }
    else {
        pm.cArg = 0;
//        printf("\n");
    }
    MessageDispatch(fd, &pm);
    delete[] pm.cArg; // Free up cArg is used
    memset(&pm, 0, 5*sizeof(int));
  }
  if(bytes <= 0){ // Shutdown the socket!
    switch(errno){
    case EAGAIN: // Don't do anything for try again
      break;
//    case 0:
//      break;     // We just read nothing, don't panic
    case EIO:
    case EISDIR:
    case EBADF:
    case EINVAL:
    case EFAULT:
    default:
      perror("PukeController: read failed");
      closefd(fd);
      close(fd);
    }
  }
  else{
    qidConnectFd[fd]->sr->setEnabled(TRUE);
  }
}
Esempio n. 9
0
	fd_t simple_socket_stoppable::create_pipe_for_stopping () {
		if (autoclose_fd && fd_to_monitor != INVALID_SOCKET) closefd(fd_to_monitor);
		fd_t pipes[2] = {INVALID_SOCKET, INVALID_SOCKET};
		if (pipe(pipes) == -1) throw socketxx::other_error("Pipe creation error in simple_socket_stoppable::create_pipe_for_stopping");
		fd_to_monitor = pipes[0];
		autoclose_fd = true;
		return pipes[1];
	}
Esempio n. 10
0
void
filesrv::remove (fh_entry *fhe)
{
  timeoutlist.remove (fhe);
  entries.remove (fhe);
  fhe_n--;
  closefd (fhe);
  delete fhe;
}
Esempio n. 11
0
vws_fini(struct waiter *w)
{
	struct vws *vws;
	void *vp;

	CAST_OBJ_NOTNULL(vws, w->priv, VWS_MAGIC);
	vws->die = 1;
	closefd(&vws->dport);
	AZ(pthread_join(vws->thread, &vp));
}
Esempio n. 12
0
void
VPF_Remove(struct vpf_fh *pfh)
{
	if (vpf_verify(pfh) == 0) {
		(void)unlink(pfh->pf_path);
		closefd(&pfh->pf_fd);
	}
	free(pfh->pf_path);
	free(pfh);
}
Esempio n. 13
0
/*
 * Copied from libvarnish/vfil.c to avoid pulling libvarnish or vfil.c
 * directly when daemon() is not working/available (i.e. OSX).
 *
 */
static void
vfil_null_fd(int target)
{
	int fd;

	assert(target >= 0);
	fd = open("/dev/null", O_RDWR);
	assert(fd >= 0);
	assert(dup2(fd, target) == target);
	closefd(&fd);
}
Esempio n. 14
0
void
filesrv::purgefd (int force)
{
  time_t curtime = time (NULL);
  for (fh_entry *fhe = timeoutlist.first; fhe != 0; 
         fhe = timeoutlist.next(fhe)) {
    if (force || (curtime > fhe->lastused + fd_expire)) {
      (void ) closefd(fhe);

    }
  }
}
Esempio n. 15
0
 StatFile::~StatFile()
 {
     for (size_t i = 0; i != sizeof(pages)/sizeof(pages[0]); ++i)
     {
         if (pages[i].ptr != 0)
         {
             mm_->unmap(pages[i].ptr, fileHeader_->page_size);
         }
     }
     if (fileHeader_)
     {
         mm_->unmap(fileHeader_, sizeof(Header));
     }
     closefd();
 }
Esempio n. 16
0
run_vcc(void *priv)
{
	struct vsb *csrc;
	struct vsb *sb = NULL;
	struct vcc_priv *vp;
	int fd, i, l;
	struct vcc *vcc;
	struct stevedore *stv;

	VJ_subproc(JAIL_SUBPROC_VCC);
	CAST_OBJ_NOTNULL(vp, priv, VCC_PRIV_MAGIC);

	AZ(chdir(vp->dir));

	vcc = VCC_New();
	AN(vcc);
	VCC_Builtin_VCL(vcc, builtin_vcl);
	VCC_VCL_path(vcc, mgt_vcl_path);
	VCC_VMOD_path(vcc, mgt_vmod_path);
	VCC_Err_Unref(vcc, mgt_vcc_err_unref);
	VCC_Allow_InlineC(vcc, mgt_vcc_allow_inline_c);
	VCC_Unsafe_Path(vcc, mgt_vcc_unsafe_path);
	STV_Foreach(stv)
		VCC_Predef(vcc, "VCL_STEVEDORE", stv->ident);
	mgt_vcl_export_labels(vcc);
	csrc = VCC_Compile(vcc, &sb, vp->vclsrc, vp->vclsrcfile);
	AZ(VSB_finish(sb));
	if (VSB_len(sb))
		printf("%s", VSB_data(sb));
	VSB_destroy(&sb);
	if (csrc == NULL)
		exit(2);

	fd = open(VGC_SRC, O_WRONLY|O_TRUNC|O_CREAT, 0600);
	if (fd < 0) {
		fprintf(stderr, "VCC cannot open %s", vp->csrcfile);
		exit(2);
	}
	l = VSB_len(csrc);
	i = write(fd, VSB_data(csrc), l);
	if (i != l) {
		fprintf(stderr, "VCC cannot write %s", vp->csrcfile);
		exit(2);
	}
	closefd(&fd);
	VSB_destroy(&csrc);
	exit(0);
}
Esempio n. 17
0
static int
mgt_vcc_touchfile(const char *fn, struct vsb *sb)
{
	int i;

	i = open(fn, O_WRONLY|O_CREAT|O_TRUNC, 0640);
	if (i < 0) {
		VSB_printf(sb, "Failed to create %s: %s", fn, strerror(errno));
		return (2);
	}
	if (fchown(i, mgt_param.uid, mgt_param.gid) != 0)
		if (geteuid() == 0)
			VSB_printf(sb, "Failed to change owner on %s: %s\n",
			    fn, strerror(errno));
	closefd(&i);
	return (0);
}
Esempio n. 18
0
int
VTCP_connected(int s)
{
	int k;
	socklen_t l;

	/* Find out if we got a connection */
	l = sizeof k;
	AZ(getsockopt(s, SOL_SOCKET, SO_ERROR, &k, &l));

	/* An error means no connection established */
	errno = k;
	if (k) {
		closefd(&s);
		return (-1);
	}

	(void)VTCP_blocking(s);
	return (s);
}
Esempio n. 19
0
int
VTCP_listen(const struct suckaddr *sa, int depth, const char **errp)
{
	int sd;
	int e;

	if (errp != NULL)
		*errp = NULL;
	sd = VTCP_bind(sa, errp);
	if (sd >= 0)  {
		if (listen(sd, depth) != 0) {
			e = errno;
			closefd(&sd);
			errno = e;
			if (errp != NULL)
				*errp = "listen(2)";
			return (-1);
		}
	}
	return (sd);
}
sender& sender::operator<<(std::istream& str){
	
	
	char c;	
//	std::cout<<"xxx: "<<str<<std::endl;
	//membaca seluruh str dan menyimpan ke string
	startSending();
	std::string msg="";
	while(str.get(c)){
		msg+=c;
		if (msg.length()>=charperframe){
			*this<<msg;
			msg="";
		}
	}
	msg+=Endfile;
	*this<<msg;
	
	stopSending(); //harusnya dipanggil waktu baca EOF
	closefd();
	return *this;
}
Esempio n. 21
0
static void
mcf_auth(struct cli *cli, const char *const *av, void *priv)
{
	int fd;
	char buf[CLI_AUTH_RESPONSE_LEN + 1];

	AN(av[2]);
	(void)priv;
	if (secret_file == NULL) {
		VCLI_Out(cli, "Secret file not configured\n");
		VCLI_SetResult(cli, CLIS_CANT);
		return;
	}
	VJ_master(JAIL_MASTER_FILE);
	fd = open(secret_file, O_RDONLY);
	if (fd < 0) {
		VCLI_Out(cli, "Cannot open secret file (%s)\n",
		    strerror(errno));
		VCLI_SetResult(cli, CLIS_CANT);
		VJ_master(JAIL_MASTER_LOW);
		return;
	}
	VJ_master(JAIL_MASTER_LOW);
	MCH_TrackHighFd(fd);
	VCLI_AuthResponse(fd, cli->challenge, buf);
	closefd(&fd);
	if (strcasecmp(buf, av[2])) {
		MGT_Complain(C_SECURITY,
		    "CLI Authentication failure from %s", cli->ident);
		VCLI_SetResult(cli, CLIS_CLOSE);
		return;
	}
	cli->auth = MCF_AUTH;
	memset(cli->challenge, 0, sizeof cli->challenge);
	VCLI_SetResult(cli, CLIS_OK);
	mcf_banner(cli, av, priv);
}
Esempio n. 22
0
/*
 * Wrapper for close - same semantics as close system call
 * except that any threads blocked in an I/O on fd will be
 * preempted and the I/O system call will return -1/EBADF.
 */
int NET_SocketClose(int fd) {
    return closefd(-1, fd);
}
Esempio n. 23
0
int mcpOpen(char *name)
{
  char host[MAXHOSTNAMELEN], service[MAXHOSTNAMELEN];

  char buf[1024];

  char *cptr;
  int count, status;

  int sock_fd;
  struct hostent *hp;
  struct servent *sp;
  struct in_addr tmpaddr;
  int optval;

  struct sockaddr_in	inet_a;  // inet_addr is a function name

#ifndef _WIN32
  char path[MAXPATHLEN];
  struct sockaddr_un	unix_addr;
  size_t		unix_addr_len;

#endif //WIN32

#ifdef _WIN32
  // make sure we are initialized
  extern struct { int initialized; } initializer;
  if (initializer.initialized == 0)
	  return -1;
#endif //WIN32

  /*
   * Parse the name string.
   *
   *  A. If there is a ':' then it is an internet socket connection.
   *	1. Parse the name into <host>:<service> format.
   *	  a. If host is empty, use "localhost".
   *	  b. Lookup service with getservbyname().  If found, use
   *	     that port value.  If not found, attempt to convert
   *	     it to an integer and use that port value.
   *	2. Connect to <host>:<port>.  If the connection fails,
   *	   attempt to connect to <host>:tcpmux then request <service>
   *	   from tcpmux.
   *  B. Else the name is a unix domain socket name.
   *    1. If the first character is not '/', prepend '/tmp/' to the
   *	   name string.
   *	2. Connect to the socket name.
   */

  cptr = strchr(name, ':');

  if (cptr)
  {
    /* Copy the host name */
    if (cptr == name)
    {
      strcpy(host, "localhost");
    }
    else
    {
      strncpy(host, name, (cptr - name));
      host[cptr-name] = '\0';
    }

    /* Copy the service name */
    strcpy(service, cptr + 1);

    /* Initialize the inet_a struct */
    bzero((char *) &inet_a, sizeof(inet_a));
    inet_a.sin_family = AF_INET;

    /* Attempt to convert the host address as a dotted decimal number */
#ifdef _WIN32
    tmpaddr.s_addr = inet_addr(host);
    status = (tmpaddr.s_addr != INADDR_NONE) ? 1 : 0;
#else
    status = inet_aton(host, &tmpaddr);
#endif //WIN32
    if (status == 1)
    {
      bcopy((char *) &tmpaddr, (char *) &inet_a.sin_addr, sizeof(tmpaddr));
    }
    else
    {
      /* Now find the host */
      hp = gethostbyname(host);

      if (!hp)
      {
	/* We could not find the host */
	errno = ENOENT;
	return -1;
      }

      bcopy(hp->h_addr, (char *) &inet_a.sin_addr, hp->h_length);
    }

    /* Attempt to decode the service parameter */
    sp = getservbyname(service, "tcp");

    if (sp)
    {
      inet_a.sin_port = sp->s_port;
    }
    else
    {
      /* Attempt to convert the service name as an integer */
      inet_a.sin_port = htons((unsigned short)atoi(service));
    }

    /* Create the socket */
    sock_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (sock_fd < 0)
    {
      return -1;
    }

    status = connect(sock_fd, (struct sockaddr *) &inet_a,
                     sizeof(inet_a));

    if (status < 0)
    {
      int status2;
      /*
       * The connection failed, try connecting to the tcpmux service.
       * tcpmux is at the well known port 1 so I just hardcoded it.
       */
      inet_a.sin_port = htons(1);

      status = errno;
      status2 = connect(sock_fd, (struct sockaddr *) &inet_a,
                        sizeof(inet_a));
      if (status2 < 0)
      {
		closefd(sock_fd);
		errno = status;
		return -1;
      }

      /*
       * We connected to tcpmux, now send the service name and see if
       * tcpmux can give it to us.  The tcpmux protocol works as follows:
       *
       *  1 Connect to the tcpmux port
       *  2 write the name of the service that you want followed by <CRLF>.
       *  3 read back the response terminated by <CRLF>
       *    a If the first character is a '+' then we are connected.
       *    b if the first character is a '-' then we are not connected.
       */
      sprintf(buf, "%s\r\n", service);
      status = mcpWrite(sock_fd, buf, (unsigned int) strlen(buf));
      if (status != (int)strlen(buf))
      {
		status = errno;
		closefd(sock_fd);
		errno = status;
		return -1;
      }

      /* Read up through the <CRLF> pair */
      /* There will be at least 3 characters coming back */
      cptr = buf;
      count = 3;
      while (1)
      {
		status = mcpRead(sock_fd, cptr, count);
		if (status <= 0)
		{
		  status = errno;
		  closefd(sock_fd);
		  errno = status;
		  return -1;
		}

		cptr += status;
		if (cptr[-1] == '\n')
		{
		  break;
		}
		else if (cptr[-1] == '\r')
		{
		  count = 1;
		}
		else
		{
		  count = 2;
		}
      }

      if (buf[0] != '+')
      {
		closefd(sock_fd);
#ifdef _WIN32
		errno = WSAECONNREFUSED;
		WSASetLastError (WSAECONNREFUSED);
#else
		errno = ECONNREFUSED;
#endif //WIN32
		return -1;
	  }
    }

    /*
     * We did it!  We actually succeeded in connecting to the name
     * via internet sockets.  Now make sure that we can send small
     * packets without delay.
     */
    optval = 1;
    status = setsockopt(sock_fd, IPPROTO_TCP, TCP_NODELAY, (void *)&optval,
			sizeof(optval));
  }
  else /* This must be a unix domain socket name */
  {
#ifndef _WIN32 // {
    /* Initialize the unix_addr struct */
    bzero((char *) &unix_addr, sizeof(unix_addr));
    unix_addr.sun_family = AF_UNIX;

    /*
     * If there is a leading '/' in the name name, it is an
     * absolute path name, otherwise, it is relative to /tmp.
     */
    if (name[0] == '/')
    {
      strcpy(path, name);
    }
    else
    {
      sprintf(path, "/tmp/%s", name);
    }

    strcpy(unix_addr.sun_path, path);
    unix_addr_len = sizeof(unix_addr.sun_len) + sizeof(unix_addr.sun_family) + strlen(path);

    /* Create the socket */
    sock_fd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (sock_fd < 0)
    {
      return -1;
    }

    /* Connect to the name */
    status = connect(sock_fd, (struct sockaddr *) &unix_addr, unix_addr_len);
    if (status < 0)
    {
      closefd(sock_fd);
      return -1;
    }

    /*
     * We did it!  We actually succeeded in connecting to the name
     * via unix sockets.
     */
#else // } {
	HANDLE h;
	void* pmem;
	DWORD *mask, bit;
	struct sockmap* map;
	int i;
	
	h = CreateFileMapping(INVALID_HANDLE_VALUE, 0, 
		PAGE_READWRITE,
		0, MAYA_UNIX_SOCKET_SHARE_SIZE,
		MAYA_UNIX_SOCKET_SHARE_NAME);
	if (!h)
		return -1;
	if (GetLastError() != ERROR_ALREADY_EXISTS)
	{
		/* no "unix" handles exist */
		CloseHandle(h);
		return -1;
	}
	
	pmem = MapViewOfFile(h, FILE_MAP_WRITE,	0, 0, 0);
	if (!pmem)
	{
		CloseHandle(h);
		return -1;
	}
	mask = (DWORD*)pmem;
	map = (struct sockmap*)((char*)pmem+sizeof(DWORD));

	/* check if name is already here */
	sock_fd = -1;
	for (bit = 1, i = 0; i < 32; ++i)
	{
		if (*mask & bit)
		{
			if (strcmp(map[i].unix_path, name) == 0)
				break; /* found */
		}
		bit = bit << 1;
	}
	
	/* found */
	if (i < 32)
	{
		/* Initialize the inet_a struct */
		bzero((char *) &inet_a, sizeof(inet_a));
		inet_a.sin_family = AF_INET;

		/* Now find the host */
		hp = gethostbyname("localhost");
		if (!hp)
			errno = ENOENT;
		else
		{
			bcopy(hp->h_addr, (char *) &inet_a.sin_addr, hp->h_length);
			inet_a.sin_port = map[i].port;

			/* Create the socket */
			sock_fd = socket(AF_INET, SOCK_STREAM, 0);
			if (sock_fd >= 0)
			{
				status = connect(sock_fd, (struct sockaddr*)&inet_a, sizeof(inet_a));
				if (status < 0)
				{
					closefd(sock_fd);
					sock_fd = -1;
					errno = status;
				}
				else
				{
					optval = 1;
					status = setsockopt(sock_fd, IPPROTO_TCP, TCP_NODELAY,
						(char*)&optval, sizeof(optval));
				}
			}
		}
	}

	UnmapViewOfFile(pmem);
	CloseHandle(h);

#endif //WIN32 }
  }

  /* Ok, we are connected.  Return the socket descriptor */
  return sock_fd;
}
Esempio n. 24
0
void mcpClose(int fd)
{
	closefd(fd);
}
Esempio n. 25
0
int main(int argc, char **argv) {
        int fd; /* File descriptor to monitor */
        int kq; /* KQueue */
        int ret; /* Return value */
        struct kevent ev;
        struct timespec ts;

        /* Don't care about our children */
        signal(SIGCHLD, SIG_IGN);

        /* Open syslog */
#ifdef DEBUG
        openlog(argv[0], LOG_CONS|LOG_PID|LOG_PERROR, LOG_DAEMON);
#else
        openlog(argv[0], LOG_CONS|LOG_PID, LOG_DAEMON);
#endif /* #ifdef DEBUG */

        /* Make sure we have at least a file and one parameter */
        if (argc < 2) {
                usage(argv[0]);
                exit(EX_USAGE);
        }

        /* Make a kqueue */
        if (-1 == (kq = kqueue())) {
                syslog(LOG_ERR, "Unable to create kqueue: %s",
                                strerror(errno));
                exit(EX_OSERR);
        }

        fd = -1;

        /* Main loop */
        for (;;) {
                /* Close the open file if we have one */
                if (-1 != fd) {
                        closefd(&fd);
                }
                /* Get a descriptor for the file to monitor */
#ifdef DEBUG
                printf("Opening %s\n", argv[1]);
#endif /* #ifdef DEBUG */
                fd = open_or_sleep(argv[1]);
#ifdef DEBUG
                printf("Opened %s: %i\n", argv[1], fd);
#endif /* #ifdef DEBUG */
                /* Set up the event */
                EV_SET(&ev, fd, EVFILT_VNODE, EV_ADD, NOTE_DELETE|NOTE_WRITE|NOTE_EXTEND|NOTE_TRUNCATE|NOTE_RENAME|NOTE_REVOKE, 0, NULL);

                /* Add the event to the kqueue */
#ifdef DEBUG
                printf("Adding event to kqueue\n");
#endif /* #ifdef DEBUG */
                if (-1 == (ret = kevent(kq, &ev, 1, NULL, 0, NULL))) {
                        /* If it fails, log it and try again */
                        syslog(LOG_WARNING, "Sleeping %is because "
                                        "setting watch on %s failed: "
                                        "%s", SLEEPTIME, argv[1],
                                        strerror(errno));

                        closefd(&fd);
                        sleep(SLEEPTIME);
                }
#ifdef DEBUG
                printf("Event added\n");
#endif /* #ifdef DEBUG */

                /* Time to sleep between logging that nothing happened */
                ts.tv_sec = KQTIME;
                ts.tv_nsec = 0;
                /* Clear kevent */
                memset((void*)&ev, 0, sizeof(ev));

#ifdef DEBUG
                printf("Waiting for a kevent\n");
#endif /* #ifdef DEBUG */
                /* Get an event from the kqueue (or timeout) */
                ret = kevent(kq, NULL, 0, &ev, 1, &ts);
#ifdef DEBUG
                printf("Got a kevent.  Ret: %i\n", ret);
#endif /* #ifdef DEBUG */

                /* Nothing has happened */
                if (0 == ret) {
                        syslog(LOG_INFO, "Still waiting for changes to %s",
                                        argv[1]);
                        continue;
                }

                /* An error occurred */
                if ((EV_ERROR & ev.flags) || ret == -1) {
                        syslog(LOG_WARNING, "Sleeping %is due to an error "
                                        "waiting for a change in %s: %s",
                                        SLEEPTIME, argv[1], strerror(errno));
                        sleep(SLEEPTIME);
                        closefd(&fd);
                        continue;
                }
                /* Log what happened */
                if (ev.fflags & NOTE_DELETE) {
                        syslog(LOG_INFO, "%s was deleted", argv[1]);
                }
                CC(NOTE_DELETE, "was deleted");
                CC(NOTE_WRITE, "was written");
                CC(NOTE_EXTEND, "was extended");
                CC(NOTE_TRUNCATE, "was truncated");
                CC(NOTE_RENAME, "was renamed");
                CC(NOTE_REVOKE, "was disappeared");

                /* Execute command if something happened and we have a
                 * command to execute */
                if (((NOTE_DELETE|NOTE_WRITE|NOTE_EXTEND|NOTE_TRUNCATE|NOTE_RENAME|NOTE_REVOKE) &
                                ev.fflags) && argc >= 3) {
#ifdef DEBUG
                        int i;
                        printf("Executing commands:\n");
                        for (i = 2; i < argc; i++)
                                printf("\targv[%i]: %s\n", i-2, argv[i]);
#endif /* #ifdef DEBUG */
                        ret = fork();
                        /* If we're the child code, execute argv[3]... */
                        if (0 == ret) {
                                execvp(argv[2], argv+2);
                                /* If execlp returned, an error occurred */
                                syslog(LOG_ERR, "Unable to execute command "
                                                "(arguments to) follow: %s",
                                                strerror(errno));
                                /* Send the arguments to syslog */
                                for (fd = 2; fd < argc; fd++) {
                                        syslog(LOG_WARNING, "%i: %s", fd,
                                                        argv[fd]);
                                }
                                return -2;
                        } else if (-1 == ret) {
                                syslog(LOG_ERR, "Command not executed "
                                                "because forking failed: %s",
                                                strerror(errno));
                        }
                }
        }
        return 0;
}
Esempio n. 26
0
/* returns an exit code */
unsigned
VSUB_run(struct vsb *sb, vsub_func_f *func, void *priv, const char *name,
    int maxlines)
{
	int rv, p[2], status;
	pid_t pid;
	struct vsub_priv sp;

	sp.sb = sb;
	sp.name = name;
	sp.lines = 0;
	sp.maxlines = maxlines;

	if (pipe(p) < 0) {
		VSB_printf(sb, "Starting %s: pipe() failed: %s",
		    name, strerror(errno));
		return (1);
	}
	assert(p[0] > STDERR_FILENO);
	assert(p[1] > STDERR_FILENO);
	if ((pid = fork()) < 0) {
		VSB_printf(sb, "Starting %s: fork() failed: %s",
		    name, strerror(errno));
		closefd(&p[0]);
		closefd(&p[1]);
		return (1);
	}
	if (pid == 0) {
		VFIL_null_fd(STDIN_FILENO);
		assert(dup2(p[1], STDOUT_FILENO) == STDOUT_FILENO);
		assert(dup2(p[1], STDERR_FILENO) == STDERR_FILENO);
		/* Close all other fds */
		VSUB_closefrom(STDERR_FILENO + 1);
		func(priv);
		/*
		 * func should either exec or exit, so getting here should be
		 * treated like an assertion failure - except that we don't know
		 * if it's safe to trigger an actual assertion
		 */
		_exit(4);
	}
	closefd(&p[1]);
	(void)VLU_File(p[0], vsub_vlu, &sp, 0);
	if (sp.maxlines >= 0 && sp.lines > sp.maxlines)
		VSB_printf(sb, "[%d lines truncated]\n",
		    sp.lines - sp.maxlines);
	do {
		rv = waitpid(pid, &status, 0);
		if (rv < 0 && errno != EINTR) {
			VSB_printf(sb, "Running %s: waitpid() failed: %s\n",
			    name, strerror(errno));
			return (1);
		}
	} while (rv < 0);
	if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
		rv = -1;
		VSB_printf(sb, "Running %s failed", name);
		if (WIFEXITED(status)) {
			rv = WEXITSTATUS(status);
			VSB_printf(sb, ", exited with %d", rv);
		}
		if (WIFSIGNALED(status)) {
			rv = 2;
			VSB_printf(sb, ", signal %d", WTERMSIG(status));
		}
		if (WCOREDUMP(status))
			VSB_printf(sb, ", core dumped");
		VSB_printf(sb, "\n");
		assert(rv != -1);
		return (rv);
	}
	return (0);
}
Esempio n. 27
0
File: app.cpp Progetto: jj4jj/dcpots
//return 0: continue, 
//return -1(<0): error
//return 1(>0): exit success
static inline int init_command(App & app, const char * pidfile){
    int ret = 0;
	if (app.cmdopt().hasopt("stop")){
		if (!pidfile){
			fprintf(stderr, "lacking command line option pid-file ...\n");
			return -1;
		}
		int killpid = lockpidfile(pidfile, SIGTERM, true);
		fprintf(stderr, "stoped process with normal stop mode [%d]\n", killpid);
        return 1;
	}
	if (app.cmdopt().hasopt("restart")){
		if (!pidfile){
			fprintf(stderr, "lacking command line option pid-file ...\n");
			return -1;
		}
		int killpid = lockpidfile(pidfile, SIGUSR1, true);
		fprintf(stderr, "stoped process with restart mode [%d]\n", killpid);
        return 1;
    }
	if (app.cmdopt().hasopt("reload")){
		if (!pidfile){
			fprintf(stderr, "lacking command line option pid-file ...\n");
			return -1;
		}
		int killpid = lockpidfile(pidfile, SIGUSR2, true, nullptr, true);
		fprintf(stderr, "reloaded process [%d]\n", killpid);
        return 1;
    }
	if (app.cmdopt().hasopt("console-shell")){
		const char * console = app.cmdopt().getoptstr("console-listen");
		if (!console){
			fprintf(stderr, "has no console-listen option open console shell error !\n");
			return -1;
		}
		string console_server = "tcp://";
		console_server += console;
		printf("connecting to %s ...\n", console_server.c_str());
		int confd = openfd(console_server.c_str(), "w", 3000);
		if (!confd){			
			fprintf(stderr, "connect error %s!\n", strerror(errno));
			return -1;
		}
		enum { CONSOLE_BUFFER_SIZE = 1024*1024};
		char * console_buffer = new char[CONSOLE_BUFFER_SIZE];
		printf("console server connected ! command <quit> will exit shell\n");
		while (true){
			int n = readfd(confd, console_buffer, CONSOLE_BUFFER_SIZE,
				"token:\r\n\r\n", 1000 * 3600);
			if (n < 0){
				fprintf(stderr, "console server closed [ret=%d]!\n", n);
				break;
			}
			printf("%s\n%s$", console_buffer, console);
			const char * command = fgets(console_buffer, CONSOLE_BUFFER_SIZE, stdin);
			if (strcasecmp(command, "quit") == 0){
				break;
			}
			dcs::writefd(confd, command, 0, "token:\r\n\r\n");
		}
		closefd(confd);
		delete console_buffer;
        return 1;
    }
    ///////////////////////////////////////////////////////////////////
    ret = _shm_command(app);
    if (ret < 0){
        GLOG_ERR("shm command check error:%d !", ret);
        return -1;
    }
    if (ret > 0){
        return 1;
    }
	return app.on_cmd_opt();
}
Esempio n. 28
0
	void simple_socket_stoppable::set_monitored_fd (fd_t to_monitor, bool autoclose) {
		if (autoclose_fd && fd_to_monitor != INVALID_SOCKET) closefd(fd_to_monitor);
		fd_to_monitor = to_monitor;
		autoclose_fd = autoclose;
		if (to_monitor == INVALID_SOCKET) throw bad_socket_error(); 
	}
Esempio n. 29
0
	void simple_socket_stoppable::unset_monitoring () {
		if (autoclose_fd && fd_to_monitor != INVALID_SOCKET) closefd(fd_to_monitor);
		fd_to_monitor = INVALID_SOCKET;
	}
Esempio n. 30
0
Joystick::~Joystick() {
    closefd();
}