/ - Diff - PeerStreamer - Redmine

     AC_SUBST(DVBD_ETC_DIR, "`eval echo ${sysconfdir}/dvbd`")
     AC_DEFINE_UNQUOTED(DEFAULT_CONFIG_FILE, "${DVBD_ETC_DIR}/config", [Default configuration file])
     AC_DEFINE_UNQUOTED(DEFAULT_SOCKET_FILE, "${DVBD_RUN_DIR}/dvbd.socket", [Default socket file])
     AC_DEFINE_UNQUOTED(DEFAULT_SOCKET_UID, "", [Default user for socket])
     AC_DEFINE_UNQUOTED(DEFAULT_SOCKET_GID, "", [Default group for socket])
     AC_DEFINE_UNQUOTED(DEFAULT_SOCKET_MODE, "", [Default permissions for socket])
     AC_DEFINE_UNQUOTED(DEFAULT_PID_FILE, "${DVBD_RUN_DIR}/dvbd.pid", [Default pid file])
     AC_DEFINE_UNQUOTED(DEFAULT_SCHEDULE_FILE, "${DVBD_SPOOL_DIR}/schedule", [Default schedule file])
     AC_DEFINE_UNQUOTED(DEFAULT_LOG_FILE, "${DVBD_LOG_DIR}/dvbd.log", [Default log file])

     usr/bin
     usr/sbin
     var/spool
     var/run
     etc
     /usr/bin
     /usr/sbin
     /var/spool
     /var/spool/dvbd
     /var/run
     /var/run/dvbd
     /etc
     /etc/dvbd

     <dt>socket</dt>
     <dd>the (unix) socket to listen on. Default is /var/run/dvbd/dvbd.socket </dd>
     <dt>socket-uid</dt>
     <dd>the user id of the socket file. The default user id is that same as the user id of the process
     running dvbd. If you user this option, dvbd probably need to run as root.</dd>
     <dt>socket-gid</dt>
     <dd>the group id of the socket file. The default user id is that same as the user id of the process
     running dvbd. If you user this option, dvbd probably need to run as root.</dd>
     <dt>socket-mode</dt>
     <dd>the mode (in octal) of the socket file. The default is to create the socket with umask of 007</dd>
     <dt>pid</dt>
     <dd>the pid file to write to once it has become a daemon. Default is /var/run/dvbd/dvbd.pid </dd>

       ConfigFile config;
       config.set("socket", DEFAULT_SOCKET_FILE);
       config.set("socket-uid", DEFAULT_SOCKET_UID);
       config.set("socket-gid", DEFAULT_SOCKET_GID);
       config.set("socket-mode", DEFAULT_SOCKET_MODE);
       config.set("pid", DEFAULT_PID_FILE);
       config.set("log", DEFAULT_LOG_FILE);
       config.set("schedule", DEFAULT_SCHEDULE_FILE);
-...
       Scheduler scheduler(config.get("schedule"), &tm, &cm);
       std::string socketFilename = config.get("socket");
       Lobby lobby(socketFilename, &tm, &cm, &scheduler);
       std::string socketUid = config.get("socket-uid");
       std::string socketGid = config.get("socket-gid");
       std::string socketMode = config.get("socket-mode");
       Lobby lobby(socketFilename, socketUid, socketGid, socketMode, &tm, &cm, &scheduler);
       setupSignalHandlers();

     #include <iostream>
     #include <unistd.h>
     Lobby::Lobby(const std::string &socketFilename, TunerManager *tm,
     	     ConnectionManager *cm, Scheduler *scheduler)
     Lobby::Lobby(const std::string &socketFilename,
     	     const std::string &socketUid,
     	     const std::string &socketGid,
     	     const std::string &socketMode,
     	     TunerManager *tm,
     	     ConnectionManager *cm,
     	     Scheduler *scheduler)
       : tm(tm), cm(cm), scheduler(scheduler)
+    {
       server = new UnixServerSocket(socketFilename);
       server = new UnixServerSocket(socketFilename, socketUid, socketGid, socketMode);
       server->setNonBlocking();
       setRandomSeed();
+    }

     class Lobby : public Selectable {
     public:
       Lobby(const std::string &socketFilename,
     	TunerManager *tm, ConnectionManager *cm,
     	const std::string &socketUid,
     	const std::string &socketGid,
     	const std::string &socketMode,
     	TunerManager *tm,
     	ConnectionManager *cm,
     	Scheduler *scheduler);
       virtual ~Lobby();

     #include <cstring>
     #include <cstdlib>
     #include <cerrno>
     #include <cstdio>
     #include <unistd.h>
     #include <sys/types.h>
     #include <sys/socket.h>
     #include <sys/un.h>
     #include <fcntl.h>
     #include <pwd.h>
     #include <grp.h>
     UnixServerSocket::UnixServerSocket(const std::string &filename)
     UnixServerSocket::UnixServerSocket(const std::string &filename,
     				   const std::string &socketUid,
     				   const std::string &socketGid,
     				   const std::string &socketMode)
       : filename(filename)
+    {
       fd = socket(PF_UNIX, SOCK_STREAM, 0);
-...
+      }
       umask(oldMask);
       // set the mode
       if (socketMode != "") {
         int mode = 0;
         sscanf(socketMode.c_str(), "%o", &mode);
         if (chmod(filename.c_str(), mode) != 0) {
           std::cerr << "Fatal error: failed to set mode on socket " << filename << "\n"
     		<< strerror(errno) << std::endl;
           exit(1);
+        }
+      }
       // set the owner
       if (socketUid != "") {
         uid_t owner;
         if (!sscanf(socketUid.c_str(), "%d", &owner)) {
           struct passwd *p = getpwnam(socketUid.c_str());
           if (p == NULL) {
     	std::cerr << "Fatal error: failed to lookup user " << socketUid << " in password database\n"
     		  << strerror(errno) << std::endl;
     	exit(1);
+          }
           owner = p->pw_uid;
+        }
         if (chown(filename.c_str(), owner, (gid_t) -1) != 0) {
           std::cerr << "Fatal error: failed to set socket ownership " << socketUid << " on " << filename << "\n"
     		<< strerror(errno) << std::endl;
           exit(1);
+        }
+      }
       // set the group
       if (socketGid != "") {
         uid_t group;
         if (!sscanf(socketGid.c_str(), "%d", &group)) {
           struct group *p = getgrnam(socketGid.c_str());
           if (p == NULL) {
     	std::cerr << "Fatal error: failed to lookup user " << socketGid << " in group database\n"
     		  << strerror(errno) << std::endl;
     	exit(1);
+          }
           group = p->gr_gid;
+        }
         if (chown(filename.c_str(), (uid_t) -1, group) != 0) {
           std::cerr << "Fatal error: failed to set socket group " << socketGid << " on " << filename << "\n"
     		<< strerror(errno) << std::endl;
           exit(1);
+        }
+      }
+    }
     void UnixServerSocket::setNonBlocking()

     class UnixServerSocket : public Selectable {
     public:
       UnixServerSocket(const std::string &filename);
       UnixServerSocket(const std::string &filename,
     		   const std::string &socketUid = "",
     		   const std::string &socketGid = "",
     		   const std::string &socketMode = "");
       virtual ~UnixServerSocket();
       void setNonBlocking();

PeerStreamer

Revision 904d298f