Make src/common/exec.c's error logging less ugly.

tglsfdc · tglsfdc · commit b6b297d20df9 · 2018-10-09T13:36:24.000-04:00
This code used elog where it really ought to use ereport, mainly so that it can report a SQLSTATE different from ERRCODE_INTERNAL_ERROR. There were some other random deviations from typical error report practice too. In addition, we can make some cleanups that were impractical six months ago: * Use one variadic macro, instead of several with different numbers of arguments, reducing the temptation to force-fit messages into particular numbers of arguments; * Use %m, even in the frontend case, simplifying the code. Discussion: https://postgr.es/m/6025.1527351693@sss.pgh.pa.us
diff --git a/src/common/exec.c b/src/common/exec.c
@@ -25,14 +25,24 @@
 #include <sys/wait.h>
 #include <unistd.h>
 
+/*
+ * Hacky solution to allow expressing both frontend and backend error reports
+ * in one macro call.  First argument of log_error is an errcode() call of
+ * some sort (ignored if FRONTEND); the rest are errmsg_internal() arguments,
+ * i.e. message string and any parameters for it.
+ *
+ * Caller must provide the gettext wrapper around the message string, if
+ * appropriate, so that it gets translated in the FRONTEND case; this
+ * motivates using errmsg_internal() not errmsg().  We handle appending a
+ * newline, if needed, inside the macro, so that there's only one translatable
+ * string per call not two.
+ */
 #ifndef FRONTEND
-/* We use only 3- and 4-parameter elog calls in this file, for simplicity */
-/* NOTE: caller must provide gettext call around str! */
-#define log_error(str, param)	elog(LOG, str, param)
-#define log_error4(str, param, arg1)	elog(LOG, str, param, arg1)
+#define log_error(errcodefn, ...) \
+	ereport(LOG, (errcodefn, errmsg_internal(__VA_ARGS__)))
 #else
-#define log_error(str, param)	(fprintf(stderr, str, param), fputc('\n', stderr))
-#define log_error4(str, param, arg1)	(fprintf(stderr, str, param, arg1), fputc('\n', stderr))
+#define log_error(errcodefn, ...) \
+	(fprintf(stderr, __VA_ARGS__), fputc('\n', stderr))
 #endif
 
 #ifdef _MSC_VER
@@ -124,10 +134,8 @@ find_my_exec(const char *argv0, char *retpath)
 
 	if (!getcwd(cwd, MAXPGPATH))
 	{
-		int			save_errno = errno;
-
-		log_error(_("could not identify current directory: %s"),
-				  strerror(save_errno));
+		log_error(errcode_for_file_access(),
+				  _("could not identify current directory: %m"));
 		return -1;
 	}
 
@@ -145,7 +153,8 @@ find_my_exec(const char *argv0, char *retpath)
 		if (validate_exec(retpath) == 0)
 			return resolve_symlinks(retpath);
 
-		log_error(_("invalid binary \"%s\""), retpath);
+		log_error(errcode(ERRCODE_WRONG_OBJECT_TYPE),
+				  _("invalid binary \"%s\""), retpath);
 		return -1;
 	}
 
@@ -194,14 +203,16 @@ find_my_exec(const char *argv0, char *retpath)
 				case -1:		/* wasn't even a candidate, keep looking */
 					break;
 				case -2:		/* found but disqualified */
-					log_error(_("could not read binary \"%s\""),
+					log_error(errcode(ERRCODE_WRONG_OBJECT_TYPE),
+							  _("could not read binary \"%s\""),
 							  retpath);
 					break;
 			}
 		} while (*endp);
 	}
 
-	log_error(_("could not find a \"%s\" to execute"), argv0);
+	log_error(errcode(ERRCODE_UNDEFINED_FILE),
+			  _("could not find a \"%s\" to execute"), argv0);
 	return -1;
 }
 
@@ -240,10 +251,8 @@ resolve_symlinks(char *path)
 	 */
 	if (!getcwd(orig_wd, MAXPGPATH))
 	{
-		int			save_errno = errno;
-
-		log_error(_("could not identify current directory: %s"),
-				  strerror(save_errno));
+		log_error(errcode_for_file_access(),
+				  _("could not identify current directory: %m"));
 		return -1;
 	}
 
@@ -258,10 +267,8 @@ resolve_symlinks(char *path)
 			*lsep = '\0';
 			if (chdir(path) == -1)
 			{
-				int			save_errno = errno;
-
-				log_error4(_("could not change directory to \"%s\": %s"),
-						   path, strerror(save_errno));
+				log_error(errcode_for_file_access(),
+						  _("could not change directory to \"%s\": %m"), path);
 				return -1;
 			}
 			fname = lsep + 1;
@@ -273,10 +280,12 @@ resolve_symlinks(char *path)
 			!S_ISLNK(buf.st_mode))
 			break;
 
+		errno = 0;
 		rllen = readlink(fname, link_buf, sizeof(link_buf));
 		if (rllen < 0 || rllen >= sizeof(link_buf))
 		{
-			log_error(_("could not read symbolic link \"%s\""), fname);
+			log_error(errcode_for_file_access(),
+					  _("could not read symbolic link \"%s\": %m"), fname);
 			return -1;
 		}
 		link_buf[rllen] = '\0';
@@ -288,21 +297,17 @@ resolve_symlinks(char *path)
 
 	if (!getcwd(path, MAXPGPATH))
 	{
-		int			save_errno = errno;
-
-		log_error(_("could not identify current directory: %s"),
-				  strerror(save_errno));
+		log_error(errcode_for_file_access(),
+				  _("could not identify current directory: %m"));
 		return -1;
 	}
 	join_path_components(path, path, link_buf);
 	canonicalize_path(path);
 
 	if (chdir(orig_wd) == -1)
 	{
-		int			save_errno = errno;
-
-		log_error4(_("could not change directory to \"%s\": %s"),
-				   orig_wd, strerror(save_errno));
+		log_error(errcode_for_file_access(),
+				  _("could not change directory to \"%s\": %m"), orig_wd);
 		return -1;
 	}
 #endif							/* HAVE_READLINK */
@@ -532,20 +537,15 @@ pclose_check(FILE *stream)
 	if (exitstatus == -1)
 	{
 		/* pclose() itself failed, and hopefully set errno */
-		int			save_errno = errno;
-
-		log_error(_("pclose failed: %s"),
-				  strerror(save_errno));
+		log_error(errcode(ERRCODE_SYSTEM_ERROR),
+				  _("pclose failed: %m"));
 	}
 	else
 	{
 		reason = wait_result_to_str(exitstatus);
-		log_error("%s", reason);
-#ifdef FRONTEND
-		free(reason);
-#else
+		log_error(errcode(ERRCODE_SYSTEM_ERROR),
+				  "%s", reason);
 		pfree(reason);
-#endif
 	}
 	return exitstatus;
 }
@@ -666,19 +666,24 @@ AddUserToTokenDacl(HANDLE hToken)
 			ptdd = (TOKEN_DEFAULT_DACL *) LocalAlloc(LPTR, dwSize);
 			if (ptdd == NULL)
 			{
-				log_error("could not allocate %lu bytes of memory", dwSize);
+				log_error(errcode(ERRCODE_OUT_OF_MEMORY),
+						  _("out of memory"));
 				goto cleanup;
 			}
 
 			if (!GetTokenInformation(hToken, tic, (LPVOID) ptdd, dwSize, &dwSize))
 			{
-				log_error("could not get token information: error code %lu", GetLastError());
+				log_error(errcode(ERRCODE_SYSTEM_ERROR),
+						  "could not get token information: error code %lu",
+						  GetLastError());
 				goto cleanup;
 			}
 		}
 		else
 		{
-			log_error("could not get token information buffer size: error code %lu", GetLastError());
+			log_error(errcode(ERRCODE_SYSTEM_ERROR),
+					  "could not get token information buffer size: error code %lu",
+					  GetLastError());
 			goto cleanup;
 		}
 	}
@@ -688,7 +693,9 @@ AddUserToTokenDacl(HANDLE hToken)
 						   (DWORD) sizeof(ACL_SIZE_INFORMATION),
 						   AclSizeInformation))
 	{
-		log_error("could not get ACL information: error code %lu", GetLastError());
+		log_error(errcode(ERRCODE_SYSTEM_ERROR),
+				  "could not get ACL information: error code %lu",
+				  GetLastError());
 		goto cleanup;
 	}
 
@@ -704,13 +711,15 @@ AddUserToTokenDacl(HANDLE hToken)
 	pacl = (PACL) LocalAlloc(LPTR, dwNewAclSize);
 	if (pacl == NULL)
 	{
-		log_error("could not allocate %lu bytes of memory", dwNewAclSize);
+		log_error(errcode(ERRCODE_OUT_OF_MEMORY),
+				  _("out of memory"));
 		goto cleanup;
 	}
 
 	if (!InitializeAcl(pacl, dwNewAclSize, ACL_REVISION))
 	{
-		log_error("could not initialize ACL: error code %lu", GetLastError());
+		log_error(errcode(ERRCODE_SYSTEM_ERROR),
+				  "could not initialize ACL: error code %lu", GetLastError());
 		goto cleanup;
 	}
 
@@ -719,21 +728,25 @@ AddUserToTokenDacl(HANDLE hToken)
 	{
 		if (!GetAce(ptdd->DefaultDacl, i, (LPVOID *) &pace))
 		{
-			log_error("could not get ACE: error code %lu", GetLastError());
+			log_error(errcode(ERRCODE_SYSTEM_ERROR),
+					  "could not get ACE: error code %lu", GetLastError());
 			goto cleanup;
 		}
 
 		if (!AddAce(pacl, ACL_REVISION, MAXDWORD, pace, ((PACE_HEADER) pace)->AceSize))
 		{
-			log_error("could not add ACE: error code %lu", GetLastError());
+			log_error(errcode(ERRCODE_SYSTEM_ERROR),
+					  "could not add ACE: error code %lu", GetLastError());
 			goto cleanup;
 		}
 	}
 
 	/* Add the new ACE for the current user */
 	if (!AddAccessAllowedAceEx(pacl, ACL_REVISION, OBJECT_INHERIT_ACE, GENERIC_ALL, pTokenUser->User.Sid))
 	{
-		log_error("could not add access allowed ACE: error code %lu", GetLastError());
+		log_error(errcode(ERRCODE_SYSTEM_ERROR),
+				  "could not add access allowed ACE: error code %lu",
+				  GetLastError());
 		goto cleanup;
 	}
 
@@ -742,7 +755,9 @@ AddUserToTokenDacl(HANDLE hToken)
 
 	if (!SetTokenInformation(hToken, tic, (LPVOID) &tddNew, dwNewAclSize))
 	{
-		log_error("could not set token information: error code %lu", GetLastError());
+		log_error(errcode(ERRCODE_SYSTEM_ERROR),
+				  "could not set token information: error code %lu",
+				  GetLastError());
 		goto cleanup;
 	}
 
@@ -788,13 +803,16 @@ GetTokenUser(HANDLE hToken, PTOKEN_USER *ppTokenUser)
 
 			if (*ppTokenUser == NULL)
 			{
-				log_error("could not allocate %lu bytes of memory", dwLength);
+				log_error(errcode(ERRCODE_OUT_OF_MEMORY),
+						  _("out of memory"));
 				return FALSE;
 			}
 		}
 		else
 		{
-			log_error("could not get token information buffer size: error code %lu", GetLastError());
+			log_error(errcode(ERRCODE_SYSTEM_ERROR),
+					  "could not get token information buffer size: error code %lu",
+					  GetLastError());
 			return FALSE;
 		}
 	}
@@ -808,7 +826,9 @@ GetTokenUser(HANDLE hToken, PTOKEN_USER *ppTokenUser)
 		LocalFree(*ppTokenUser);
 		*ppTokenUser = NULL;
 
-		log_error("could not get token information: error code %lu", GetLastError());
+		log_error(errcode(ERRCODE_SYSTEM_ERROR),
+				  "could not get token information: error code %lu",
+				  GetLastError());
 		return FALSE;
 	}
 

Original file line number	Diff line number	Diff line change
`@@ -25,14 +25,24 @@`
`25`	`25`	`#include <sys/wait.h>`
`26`	`26`	`#include <unistd.h>`
`27`	`27`
	`28`	`+/*`
	`29`	`+ * Hacky solution to allow expressing both frontend and backend error reports`
	`30`	`+ * in one macro call. First argument of log_error is an errcode() call of`
	`31`	`+ * some sort (ignored if FRONTEND); the rest are errmsg_internal() arguments,`
	`32`	`+ * i.e. message string and any parameters for it.`
	`33`	`+ *`
	`34`	`+ * Caller must provide the gettext wrapper around the message string, if`
	`35`	`+ * appropriate, so that it gets translated in the FRONTEND case; this`
	`36`	`+ * motivates using errmsg_internal() not errmsg(). We handle appending a`
	`37`	`+ * newline, if needed, inside the macro, so that there's only one translatable`
	`38`	`+ * string per call not two.`
	`39`	`+ */`
`28`	`40`	`#ifndef FRONTEND`
`29`		`-/* We use only 3- and 4-parameter elog calls in this file, for simplicity */`
`30`		`-/* NOTE: caller must provide gettext call around str! */`
`31`		`-#define log_error(str, param) elog(LOG, str, param)`
`32`		`-#define log_error4(str, param, arg1) elog(LOG, str, param, arg1)`
	`41`	`+#define log_error(errcodefn, ...) \`
	`42`	`+ ereport(LOG, (errcodefn, errmsg_internal(__VA_ARGS__)))`
`33`	`43`	`#else`
`34`		`-#define log_error(str, param) (fprintf(stderr, str, param), fputc('\n', stderr))`
`35`		`-#define log_error4(str, param, arg1) (fprintf(stderr, str, param, arg1), fputc('\n', stderr))`
	`44`	`+#define log_error(errcodefn, ...) \`
	`45`	`+ (fprintf(stderr, __VA_ARGS__), fputc('\n', stderr))`
`36`	`46`	`#endif`
`37`	`47`
`38`	`48`	`#ifdef _MSC_VER`
`@@ -124,10 +134,8 @@ find_my_exec(const char argv0, char retpath)`
`124`	`134`
`125`	`135`	`if (!getcwd(cwd, MAXPGPATH))`
`126`	`136`	`{`
`127`		`- int save_errno = errno;`
`128`		`-`
`129`		`- log_error(_("could not identify current directory: %s"),`
`130`		`- strerror(save_errno));`
	`137`	`+ log_error(errcode_for_file_access(),`
	`138`	`+ _("could not identify current directory: %m"));`
`131`	`139`	`return -1;`
`132`	`140`	`}`
`133`	`141`
`@@ -145,7 +153,8 @@ find_my_exec(const char argv0, char retpath)`
`145`	`153`	`if (validate_exec(retpath) == 0)`
`146`	`154`	`return resolve_symlinks(retpath);`
`147`	`155`
`148`		`- log_error(_("invalid binary \"%s\""), retpath);`
	`156`	`+ log_error(errcode(ERRCODE_WRONG_OBJECT_TYPE),`
	`157`	`+ _("invalid binary \"%s\""), retpath);`
`149`	`158`	`return -1;`
`150`	`159`	`}`
`151`	`160`
`@@ -194,14 +203,16 @@ find_my_exec(const char argv0, char retpath)`
`194`	`203`	`case -1: /* wasn't even a candidate, keep looking */`
`195`	`204`	`break;`
`196`	`205`	`case -2: /* found but disqualified */`
`197`		`- log_error(_("could not read binary \"%s\""),`
	`206`	`+ log_error(errcode(ERRCODE_WRONG_OBJECT_TYPE),`
	`207`	`+ _("could not read binary \"%s\""),`
`198`	`208`	`retpath);`
`199`	`209`	`break;`
`200`	`210`	`}`
`201`	`211`	`} while (*endp);`
`202`	`212`	`}`
`203`	`213`
`204`		`- log_error(_("could not find a \"%s\" to execute"), argv0);`
	`214`	`+ log_error(errcode(ERRCODE_UNDEFINED_FILE),`
	`215`	`+ _("could not find a \"%s\" to execute"), argv0);`
`205`	`216`	`return -1;`
`206`	`217`	`}`
`207`	`218`
`@@ -240,10 +251,8 @@ resolve_symlinks(char *path)`
`240`	`251`	`*/`
`241`	`252`	`if (!getcwd(orig_wd, MAXPGPATH))`
`242`	`253`	`{`
`243`		`- int save_errno = errno;`
`244`		`-`
`245`		`- log_error(_("could not identify current directory: %s"),`
`246`		`- strerror(save_errno));`
	`254`	`+ log_error(errcode_for_file_access(),`
	`255`	`+ _("could not identify current directory: %m"));`
`247`	`256`	`return -1;`
`248`	`257`	`}`
`249`	`258`
`@@ -258,10 +267,8 @@ resolve_symlinks(char *path)`
`258`	`267`	`*lsep = '\0';`
`259`	`268`	`if (chdir(path) == -1)`
`260`	`269`	`{`
`261`		`- int save_errno = errno;`
`262`		`-`
`263`		`- log_error4(_("could not change directory to \"%s\": %s"),`
`264`		`- path, strerror(save_errno));`
	`270`	`+ log_error(errcode_for_file_access(),`
	`271`	`+ _("could not change directory to \"%s\": %m"), path);`
`265`	`272`	`return -1;`
`266`	`273`	`}`
`267`	`274`	`fname = lsep + 1;`
`@@ -273,10 +280,12 @@ resolve_symlinks(char *path)`
`273`	`280`	`!S_ISLNK(buf.st_mode))`
`274`	`281`	`break;`
`275`	`282`
	`283`	`+ errno = 0;`
`276`	`284`	`rllen = readlink(fname, link_buf, sizeof(link_buf));`
`277`	`285`	`if (rllen < 0 \|\| rllen >= sizeof(link_buf))`
`278`	`286`	`{`
`279`		`- log_error(_("could not read symbolic link \"%s\""), fname);`
	`287`	`+ log_error(errcode_for_file_access(),`
	`288`	`+ _("could not read symbolic link \"%s\": %m"), fname);`
`280`	`289`	`return -1;`
`281`	`290`	`}`
`282`	`291`	`link_buf[rllen] = '\0';`
`@@ -288,21 +297,17 @@ resolve_symlinks(char *path)`
`288`	`297`
`289`	`298`	`if (!getcwd(path, MAXPGPATH))`
`290`	`299`	`{`
`291`		`- int save_errno = errno;`
`292`		`-`
`293`		`- log_error(_("could not identify current directory: %s"),`
`294`		`- strerror(save_errno));`
	`300`	`+ log_error(errcode_for_file_access(),`
	`301`	`+ _("could not identify current directory: %m"));`
`295`	`302`	`return -1;`
`296`	`303`	`}`
`297`	`304`	`join_path_components(path, path, link_buf);`
`298`	`305`	`canonicalize_path(path);`
`299`	`306`
`300`	`307`	`if (chdir(orig_wd) == -1)`
`301`	`308`	`{`
`302`		`- int save_errno = errno;`
`303`		`-`
`304`		`- log_error4(_("could not change directory to \"%s\": %s"),`
`305`		`- orig_wd, strerror(save_errno));`
	`309`	`+ log_error(errcode_for_file_access(),`
	`310`	`+ _("could not change directory to \"%s\": %m"), orig_wd);`
`306`	`311`	`return -1;`
`307`	`312`	`}`
`308`	`313`	`#endif /* HAVE_READLINK */`
`@@ -532,20 +537,15 @@ pclose_check(FILE *stream)`
`532`	`537`	`if (exitstatus == -1)`
`533`	`538`	`{`
`534`	`539`	`/* pclose() itself failed, and hopefully set errno */`
`535`		`- int save_errno = errno;`
`536`		`-`
`537`		`- log_error(_("pclose failed: %s"),`
`538`		`- strerror(save_errno));`
	`540`	`+ log_error(errcode(ERRCODE_SYSTEM_ERROR),`
	`541`	`+ _("pclose failed: %m"));`
`539`	`542`	`}`
`540`	`543`	`else`
`541`	`544`	`{`
`542`	`545`	`reason = wait_result_to_str(exitstatus);`
`543`		`- log_error("%s", reason);`
`544`		`-#ifdef FRONTEND`
`545`		`- free(reason);`
`546`		`-#else`
	`546`	`+ log_error(errcode(ERRCODE_SYSTEM_ERROR),`
	`547`	`+ "%s", reason);`
`547`	`548`	`pfree(reason);`
`548`		`-#endif`
`549`	`549`	`}`
`550`	`550`	`return exitstatus;`
`551`	`551`	`}`
`@@ -666,19 +666,24 @@ AddUserToTokenDacl(HANDLE hToken)`
`666`	`666`	`ptdd = (TOKEN_DEFAULT_DACL *) LocalAlloc(LPTR, dwSize);`
`667`	`667`	`if (ptdd == NULL)`
`668`	`668`	`{`
`669`		`- log_error("could not allocate %lu bytes of memory", dwSize);`
	`669`	`+ log_error(errcode(ERRCODE_OUT_OF_MEMORY),`
	`670`	`+ _("out of memory"));`
`670`	`671`	`goto cleanup;`
`671`	`672`	`}`
`672`	`673`
`673`	`674`	`if (!GetTokenInformation(hToken, tic, (LPVOID) ptdd, dwSize, &dwSize))`
`674`	`675`	`{`
`675`		`- log_error("could not get token information: error code %lu", GetLastError());`
	`676`	`+ log_error(errcode(ERRCODE_SYSTEM_ERROR),`
	`677`	`+ "could not get token information: error code %lu",`
	`678`	`+ GetLastError());`
`676`	`679`	`goto cleanup;`
`677`	`680`	`}`
`678`	`681`	`}`
`679`	`682`	`else`
`680`	`683`	`{`
`681`		`- log_error("could not get token information buffer size: error code %lu", GetLastError());`
	`684`	`+ log_error(errcode(ERRCODE_SYSTEM_ERROR),`
	`685`	`+ "could not get token information buffer size: error code %lu",`
	`686`	`+ GetLastError());`
`682`	`687`	`goto cleanup;`
`683`	`688`	`}`
`684`	`689`	`}`
`@@ -688,7 +693,9 @@ AddUserToTokenDacl(HANDLE hToken)`
`688`	`693`	`(DWORD) sizeof(ACL_SIZE_INFORMATION),`
`689`	`694`	`AclSizeInformation))`
`690`	`695`	`{`
`691`		`- log_error("could not get ACL information: error code %lu", GetLastError());`
	`696`	`+ log_error(errcode(ERRCODE_SYSTEM_ERROR),`
	`697`	`+ "could not get ACL information: error code %lu",`
	`698`	`+ GetLastError());`
`692`	`699`	`goto cleanup;`
`693`	`700`	`}`
`694`	`701`
`@@ -704,13 +711,15 @@ AddUserToTokenDacl(HANDLE hToken)`
`704`	`711`	`pacl = (PACL) LocalAlloc(LPTR, dwNewAclSize);`
`705`	`712`	`if (pacl == NULL)`
`706`	`713`	`{`
`707`		`- log_error("could not allocate %lu bytes of memory", dwNewAclSize);`
	`714`	`+ log_error(errcode(ERRCODE_OUT_OF_MEMORY),`
	`715`	`+ _("out of memory"));`
`708`	`716`	`goto cleanup;`
`709`	`717`	`}`
`710`	`718`
`711`	`719`	`if (!InitializeAcl(pacl, dwNewAclSize, ACL_REVISION))`
`712`	`720`	`{`
`713`		`- log_error("could not initialize ACL: error code %lu", GetLastError());`
	`721`	`+ log_error(errcode(ERRCODE_SYSTEM_ERROR),`
	`722`	`+ "could not initialize ACL: error code %lu", GetLastError());`
`714`	`723`	`goto cleanup;`
`715`	`724`	`}`
`716`	`725`
`@@ -719,21 +728,25 @@ AddUserToTokenDacl(HANDLE hToken)`
`719`	`728`	`{`
`720`	`729`	`if (!GetAce(ptdd->DefaultDacl, i, (LPVOID *) &pace))`
`721`	`730`	`{`
`722`		`- log_error("could not get ACE: error code %lu", GetLastError());`
	`731`	`+ log_error(errcode(ERRCODE_SYSTEM_ERROR),`
	`732`	`+ "could not get ACE: error code %lu", GetLastError());`
`723`	`733`	`goto cleanup;`
`724`	`734`	`}`
`725`	`735`
`726`	`736`	`if (!AddAce(pacl, ACL_REVISION, MAXDWORD, pace, ((PACE_HEADER) pace)->AceSize))`
`727`	`737`	`{`
`728`		`- log_error("could not add ACE: error code %lu", GetLastError());`
	`738`	`+ log_error(errcode(ERRCODE_SYSTEM_ERROR),`
	`739`	`+ "could not add ACE: error code %lu", GetLastError());`
`729`	`740`	`goto cleanup;`
`730`	`741`	`}`
`731`	`742`	`}`
`732`	`743`
`733`	`744`	`/* Add the new ACE for the current user */`
`734`	`745`	`if (!AddAccessAllowedAceEx(pacl, ACL_REVISION, OBJECT_INHERIT_ACE, GENERIC_ALL, pTokenUser->User.Sid))`
`735`	`746`	`{`
`736`		`- log_error("could not add access allowed ACE: error code %lu", GetLastError());`
	`747`	`+ log_error(errcode(ERRCODE_SYSTEM_ERROR),`
	`748`	`+ "could not add access allowed ACE: error code %lu",`
	`749`	`+ GetLastError());`
`737`	`750`	`goto cleanup;`
`738`	`751`	`}`
`739`	`752`
`@@ -742,7 +755,9 @@ AddUserToTokenDacl(HANDLE hToken)`
`742`	`755`
`743`	`756`	`if (!SetTokenInformation(hToken, tic, (LPVOID) &tddNew, dwNewAclSize))`
`744`	`757`	`{`
`745`		`- log_error("could not set token information: error code %lu", GetLastError());`
	`758`	`+ log_error(errcode(ERRCODE_SYSTEM_ERROR),`
	`759`	`+ "could not set token information: error code %lu",`
	`760`	`+ GetLastError());`
`746`	`761`	`goto cleanup;`
`747`	`762`	`}`
`748`	`763`
`@@ -788,13 +803,16 @@ GetTokenUser(HANDLE hToken, PTOKEN_USER *ppTokenUser)`
`788`	`803`
`789`	`804`	`if (*ppTokenUser == NULL)`
`790`	`805`	`{`
`791`		`- log_error("could not allocate %lu bytes of memory", dwLength);`
	`806`	`+ log_error(errcode(ERRCODE_OUT_OF_MEMORY),`
	`807`	`+ _("out of memory"));`
`792`	`808`	`return FALSE;`
`793`	`809`	`}`
`794`	`810`	`}`
`795`	`811`	`else`
`796`	`812`	`{`
`797`		`- log_error("could not get token information buffer size: error code %lu", GetLastError());`
	`813`	`+ log_error(errcode(ERRCODE_SYSTEM_ERROR),`
	`814`	`+ "could not get token information buffer size: error code %lu",`
	`815`	`+ GetLastError());`
`798`	`816`	`return FALSE;`
`799`	`817`	`}`
`800`	`818`	`}`
`@@ -808,7 +826,9 @@ GetTokenUser(HANDLE hToken, PTOKEN_USER *ppTokenUser)`
`808`	`826`	`LocalFree(*ppTokenUser);`
`809`	`827`	`*ppTokenUser = NULL;`
`810`	`828`
`811`		`- log_error("could not get token information: error code %lu", GetLastError());`
	`829`	`+ log_error(errcode(ERRCODE_SYSTEM_ERROR),`
	`830`	`+ "could not get token information: error code %lu",`
	`831`	`+ GetLastError());`
`812`	`832`	`return FALSE;`
`813`	`833`	`}`
`814`	`834`