C++-ify lib.misc.cc.

Author: meisterT

judge/evict.cc

@@ -12,9 +12,10 @@
 #include <cstring>
 #include <cstdlib>
 
+#include "lib.misc.h"
+
 extern "C" {
 #include "lib.error.h"
-#include "lib.misc.h"
 }
 
 #define PROGRAM "evict"

judge/runpipe.cc

@@ -66,6 +66,7 @@
 #include "lib.misc.h"
 
 #include <algorithm>
+#include <array>
 #include <chrono>
 #include <csignal>
 #include <cstring>
@@ -232,22 +233,17 @@ struct process_t {
 
   // Fork and exec the child process, redirecting its standard I/O.
   void spawn() {
-    fd_t stdio[3] = {stdin_fd, stdout_fd, FDREDIR_NONE};
-
-    char pid_buf[12];
-    vector<const char *> argv;
-    for (size_t i = 0; i < args.size(); i++) {
-      argv.push_back(args[i].c_str());
-      if (i == 1 && cmd == "sudo" &&
-          args[i].find("/runguard") != string::npos) {
+    std::array<int, 3> stdio = {stdin_fd, stdout_fd, FDREDIR_NONE};
+
+    auto exec_args = args;
+    if (cmd == "sudo" && exec_args.size() > 1 && exec_args[1].find("/runguard") != string::npos) {
         // This is a hack, and can be improved significantly after implementing
         // https://docs.google.com/document/d/1WZRwdvJUamsczYC7CpP3ZIBU8xG6wNqYqrNJf7osxYs/edit#heading=h.i7kgdnmw8qd7
-        argv.push_back("-U");
-        sprintf(pid_buf, "%d", getpid());
-        argv.push_back(pid_buf);
-      }
+        exec_args.push_back("-U");
+        exec_args.push_back(std::to_string(getpid()));
     }
-    pid = execute(cmd.c_str(), argv.data(), argv.size(), stdio, 0);
+
+    pid = execute(cmd, exec_args, stdio, false);
     if (pid < 0) {
       error(errno, "failed to execute command #%ld", index);
     }

lib/lib.misc.cc

@@ -7,91 +7,83 @@
 
 #include "config.h"
 
-#include <stdlib.h>
+#include <cstdlib>
 #include <unistd.h>
-#include <string.h>
-#include <stdarg.h>
-#include <signal.h>
+#include <cstring>
+#include <cstdarg>
+#include <csignal>
 #include <sys/wait.h>
 #include <fcntl.h>
+#include <vector>
+#include <iostream>
 
 #include "lib.misc.h"
 #include "lib.error.h"
 
 /* Array indices for input/output file descriptors as used by pipe() */
-#define PIPE_IN  1
-#define PIPE_OUT 0
+constexpr int PIPE_IN = 1;
+constexpr int PIPE_OUT = 0;
 
 const int def_stdio_fd[3] = { STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO };
 
-int execute(const char *cmd, const char **args, int nargs, int stdio_fd[3], int err2out)
+int execute(const std::string& cmd, const std::vector<std::string>& args,
+            std::array<int, 3>& stdio_fd, bool err2out)
 {
-	pid_t pid, child_pid;
-	int redirect;
-	int status;
-	int pipe_fd[3][2];
-	char **argv;
-	int i, dir;
-
-	if ( (argv=(char **) malloc((nargs+2)*sizeof(char *)))==NULL ) return -1;
-
 	if ( err2out ) stdio_fd[2] = FDREDIR_NONE;
 
-	redirect = ( stdio_fd[0]!=FDREDIR_NONE ||
-	             stdio_fd[1]!=FDREDIR_NONE ||
-	             stdio_fd[2]!=FDREDIR_NONE );
+	const bool redirect = ( stdio_fd[0]!=FDREDIR_NONE ||
+	                        stdio_fd[1]!=FDREDIR_NONE ||
+	                        stdio_fd[2]!=FDREDIR_NONE );
 
-	/* Build the complete argument list for execvp.
-	 * We can const-cast the pointers, since execvp is guaranteed
-	 * not to modify these (or the data pointed to).
-	 */
-	argv[0] = (char *) cmd;
-	for(i=0; i<nargs; i++) argv[i+1] = (char *) args[i];
-	argv[nargs+1] = NULL;
+	std::vector<char *> argv;
+	argv.push_back(const_cast<char*>(cmd.c_str()));
+	for (const auto& arg : args) {
+		argv.push_back(const_cast<char*>(arg.c_str()));
+	}
+	argv.push_back(nullptr);
 
+	int pipe_fd[3][2];
 	/* Open pipes for IO redirection */
-	for(i=0; i<3; i++) {
-		if ( stdio_fd[i]==FDREDIR_PIPE && pipe(pipe_fd[i])!=0 ) goto ret_error;
+	for(int i=0; i<3; i++) {
+		if ( stdio_fd[i]==FDREDIR_PIPE && pipe(pipe_fd[i])!=0 ) return -1;
 	}
 
+	pid_t child_pid;
 	switch ( child_pid = fork() ) {
 	case -1: /* error */
-		free(argv);
 		return -1;
 
 	case  0: /* child process */
 		/* Connect pipes to command stdin/stdout/stderr and close unneeded fd's */
-		for(i=0; i<3; i++) {
+		for(int i=0; i<3; i++) {
 			if ( stdio_fd[i]==FDREDIR_PIPE ) {
 				/* stdin must be connected to the pipe output,
 				   stdout/stderr to the pipe input: */
-				dir = (i==0 ? PIPE_OUT : PIPE_IN);
-				if ( dup2(pipe_fd[i][dir],def_stdio_fd[i])<0 ) goto ret_error;
-				if ( close(pipe_fd[i][dir])!=0 ) goto ret_error;
-				if ( close(pipe_fd[i][1-dir])!=0 ) goto ret_error;
+				const int dir = (i==0 ? PIPE_OUT : PIPE_IN);
+				if ( dup2(pipe_fd[i][dir],def_stdio_fd[i])<0 ) return -1;
+				if ( close(pipe_fd[i][dir])!=0 ) return -1;
+				if ( close(pipe_fd[i][1-dir])!=0 ) return -1;
 			}
 			if ( stdio_fd[i]>=0 ) {
-				if ( dup2(stdio_fd[i],def_stdio_fd[i])<0 ) goto ret_error;
-				if ( close(stdio_fd[i])!=0 ) goto ret_error;
+				if ( dup2(stdio_fd[i],def_stdio_fd[i])<0 ) return -1;
+				if ( close(stdio_fd[i])!=0 ) return -1;
 			}
 		}
 		/* Redirect stderr to stdout */
-		if ( err2out && dup2(STDOUT_FILENO,STDERR_FILENO)<0 ) goto ret_error;
+		if ( err2out && dup2(STDOUT_FILENO,STDERR_FILENO)<0 ) return -1;
 
 		/* Replace child with command */
-		execvp(cmd,argv);
+		execvp(cmd.c_str(), argv.data());
 		abort();
 
 	default: /* parent process */
 
-		free(argv);
-
 		/* Set and close file descriptors */
-		for(i=0; i<3; i++) {
+		for(int i=0; i<3; i++) {
 			if ( stdio_fd[i]==FDREDIR_PIPE ) {
 				/* parent process output must connect to the input of
 				   the pipe to child, and vice versa for stdout/stderr: */
-				dir = (i==0 ? PIPE_IN : PIPE_OUT);
+				const int dir = (i==0 ? PIPE_IN : PIPE_OUT);
 				stdio_fd[i] = pipe_fd[i][dir];
 				if ( close(pipe_fd[i][1-dir])!=0 ) return -1;
 			}
@@ -101,6 +93,8 @@ int execute(const char *cmd, const char **args, int nargs, int stdio_fd[3], int
 		if ( redirect ) return child_pid;
 
 		/* Wait for the child command to finish */
+		int status;
+		pid_t pid;
 		while ( (pid = wait(&status))!=-1 && pid!=child_pid );
 		if ( pid!=child_pid ) return -1;
 
@@ -115,21 +109,15 @@ int execute(const char *cmd, const char **args, int nargs, int stdio_fd[3], int
 
 	/* This should never be reached */
 	return -2;
-
-	/* Handle resources before returning on error */
-  ret_error:
-	free(argv);
-	return -1;
 }
 
 
 void version(const char *prog, const char *vers)
 {
-	printf("\
-%s -- part of DOMjudge version %s\n\
-Written by the DOMjudge developers\n\n\
-DOMjudge comes with ABSOLUTELY NO WARRANTY.  This is free software, and you\n\
-are welcome to redistribute it under certain conditions.  See the GNU\n\
-General Public Licence for details.\n", prog, vers);
+	std::cout << prog << " -- part of DOMjudge version " << vers << std::endl
+	          << "Written by the DOMjudge developers" << std::endl << std::endl
+	          << "DOMjudge comes with ABSOLUTELY NO WARRANTY.  This is free software, and you" << std::endl
+	          << "are welcome to redistribute it under certain conditions.  See the GNU" << std::endl
+	          << "General Public Licence for details." << std::endl;
 	exit(0);
-}
+}

lib/lib.misc.h

@@ -5,9 +5,9 @@
 #ifndef LIB_MISC_H
 #define LIB_MISC_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+#include <string>
+#include <vector>
+#include <array>
 
 /* I/O redirection options for execute() */
 #define FDREDIR_NONE -1
@@ -17,23 +17,22 @@ extern "C" {
  * LIBDIR as defined in calling program. */
 #define alert(msgtype,description) _alert(LIBDIR,msgtype,description)
 
-int execute(const char *, const char **, int, int[3], int)
-    __attribute__((nonnull (1, 2)));
+int execute(const std::string& cmd, const std::vector<std::string>& args,
+            std::array<int, 3>& stdio_fd, bool err2out);
 /* Execute a subprocess using fork and execvp and optionally perform
  * IO redirection of stdin/stdout/stderr.
  *
  * Arguments:
- * char *cmd        command to be executed (PATH is searched)
- * char *args[]     array of arguments to command
- * int nargs        number of arguments specified
- * int stdio_fd[3]  File descriptors for stdin, stdout and stderr respectively.
- *                    Each can separately be set to one of the following:
- *                      FDREDIR_NONE - don't do redirection
- *                      FDREDIR_PIPE - connect to pipe and set value to file
- *                                     descriptor of other end of the pipe
- *                      fd >= 0      - make this a duplicate of <fd>
- * int err2out      Set non-zero to redirect command stderr to stdout. When set
- *                    the redirection of stderr by stdio_fd[2] is ignored.
+ * const std::string& cmd                command to be executed (PATH is searched)
+ * const std::vector<std::string>& args  vector of arguments to command
+ * std::array<int, 3>& stdio_fd          File descriptors for stdin, stdout and stderr respectively.
+ *      Each can separately be set to one of the following:
+ *        FDREDIR_NONE - don't do redirection
+ *        FDREDIR_PIPE - connect to pipe and set value to file
+ *                       descriptor of other end of the pipe
+ *        fd >= 0      - make this a duplicate of <fd>
+ * bool err2out                          Set to true to redirect command stderr to stdout. When set
+ *                                       the redirection of stderr by stdio_fd[2] is ignored.
  *
  * Returns:
  * On errors from system calls -1 is returned: check errno for extra information.
@@ -47,14 +46,9 @@ int execute(const char *, const char **, int, int[3], int)
  * with the process-ID of the child command.
  */
 
-
 void version(const char *, const char *) __attribute__((nonnull (1, 2)));
 /* Print standard program name and version, with disclaimer and GPL
  * licence info. Arguments: program name and version strings.
  */
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* LIB_MISC_H */