io.cpp

   1 #include "nssm.h"\r
   2 \r
   3 /* Get path, share mode, creation disposition and flags for a stream. */\r
   4 int get_createfile_parameters(HKEY key, TCHAR *prefix, TCHAR *path, unsigned long *sharing, unsigned long default_sharing, unsigned long *disposition, unsigned long default_disposition, unsigned long *flags, unsigned long default_flags) {\r
   5   TCHAR value[NSSM_STDIO_LENGTH];\r
   6 \r
   7   /* Path. */\r
   8   if (_sntprintf_s(value, _countof(value), _TRUNCATE, _T("%s"), prefix) < 0) {\r
   9     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, prefix, _T("get_createfile_parameters()"), 0);\r
  10     return 1;\r
  11   }\r
  12   switch (expand_parameter(key, value, path, MAX_PATH, true, false)) {\r
  13     case 0: if (! path[0]) return 0; break; /* OK. */\r
  14     default: return 2; /* Error. */\r
  15   }\r
  16 \r
  17   /* ShareMode. */\r
  18   if (_sntprintf_s(value, _countof(value), _TRUNCATE, _T("%s%s"), prefix, NSSM_REG_STDIO_SHARING) < 0) {\r
  19     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, NSSM_REG_STDIO_SHARING, _T("get_createfile_parameters()"), 0);\r
  20     return 3;\r
  21   }\r
  22   switch (get_number(key, value, sharing, false)) {\r
  23     case 0: *sharing = default_sharing; break; /* Missing. */\r
  24     case 1: break; /* Found. */\r
  25     case -2: return 4; break; /* Error. */\r
  26   }\r
  27 \r
  28   /* CreationDisposition. */\r
  29   if (_sntprintf_s(value, _countof(value), _TRUNCATE, _T("%s%s"), prefix, NSSM_REG_STDIO_DISPOSITION) < 0) {\r
  30     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, NSSM_REG_STDIO_DISPOSITION, _T("get_createfile_parameters()"), 0);\r
  31     return 5;\r
  32   }\r
  33   switch (get_number(key, value, disposition, false)) {\r
  34     case 0: *disposition = default_disposition; break; /* Missing. */\r
  35     case 1: break; /* Found. */\r
  36     case -2: return 6; break; /* Error. */\r
  37   }\r
  38 \r
  39   /* Flags. */\r
  40   if (_sntprintf_s(value, _countof(value), _TRUNCATE, _T("%s%s"), prefix, NSSM_REG_STDIO_FLAGS) < 0) {\r
  41     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, NSSM_REG_STDIO_FLAGS, _T("get_createfile_parameters()"), 0);\r
  42     return 7;\r
  43   }\r
  44   switch (get_number(key, value, flags, false)) {\r
  45     case 0: *flags = default_flags; break; /* Missing. */\r
  46     case 1: break; /* Found. */\r
  47     case -2: return 8; break; /* Error. */\r
  48   }\r
  49 \r
  50   return 0;\r
  51 }\r
  52 \r
  53 int set_createfile_parameter(HKEY key, TCHAR *prefix, TCHAR *suffix, unsigned long number) {\r
  54   TCHAR value[NSSM_STDIO_LENGTH];\r
  55 \r
  56   if (_sntprintf_s(value, _countof(value), _TRUNCATE, _T("%s%s"), prefix, suffix) < 0) {\r
  57     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, suffix, _T("set_createfile_parameter()"), 0);\r
  58     return 1;\r
  59   }\r
  60 \r
  61   return set_number(key, value, number);\r
  62 }\r
  63 \r
  64 int delete_createfile_parameter(HKEY key, TCHAR *prefix, TCHAR *suffix) {\r
  65   TCHAR value[NSSM_STDIO_LENGTH];\r
  66 \r
  67   if (_sntprintf_s(value, _countof(value), _TRUNCATE, _T("%s%s"), prefix, suffix) < 0) {\r
  68     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_OUT_OF_MEMORY, suffix, _T("delete_createfile_parameter()"), 0);\r
  69     return 1;\r
  70   }\r
  71 \r
  72   if (RegDeleteValue(key, value)) return 0;\r
  73   return 1;\r
  74 }\r
  75 \r
  76 HANDLE append_to_file(TCHAR *path, unsigned long sharing, SECURITY_ATTRIBUTES *attributes, unsigned long disposition, unsigned long flags) {\r
  77   HANDLE ret;\r
  78 \r
  79   /* Try to append to the file first. */\r
  80   ret = CreateFile(path, FILE_APPEND_DATA, sharing, attributes, disposition, flags, 0);\r
  81   if (ret) {\r
  82     SetEndOfFile(ret);\r
  83     return ret;\r
  84   }\r
  85 \r
  86   unsigned long error = GetLastError();\r
  87   if (error != ERROR_FILE_NOT_FOUND) {\r
  88     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATEFILE_FAILED, path, error_string(error), 0);\r
  89     return (HANDLE) 0;\r
  90   }\r
  91 \r
  92   /* It didn't exist.  Create it. */\r
  93   return CreateFile(path, FILE_WRITE_DATA, sharing, attributes, disposition, flags, 0);\r
  94 }\r
  95 \r
  96 void rotate_file(TCHAR *service_name, TCHAR *path, unsigned long seconds, unsigned long low, unsigned long high) {\r
  97   unsigned long error;\r
  98 \r
  99   /* Now. */\r
 100   SYSTEMTIME st;\r
 101   GetSystemTime(&st);\r
 102 \r
 103   BY_HANDLE_FILE_INFORMATION info;\r
 104 \r
 105   /* Try to open the file to check if it exists and to get attributes. */\r
 106   HANDLE file = CreateFile(path, 0, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);\r
 107   if (file) {\r
 108     /* Get file attributes. */\r
 109     if (! GetFileInformationByHandle(file, &info)) {\r
 110       /* Reuse current time for rotation timestamp. */\r
 111       seconds = low = high = 0;\r
 112       SystemTimeToFileTime(&st, &info.ftLastWriteTime);\r
 113     }\r
 114 \r
 115     CloseHandle(file);\r
 116   }\r
 117   else {\r
 118     error = GetLastError();\r
 119     if (error == ERROR_FILE_NOT_FOUND) return;\r
 120     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_ROTATE_FILE_FAILED, service_name, path, _T("CreateFile()"), path, error_string(error), 0);\r
 121     /* Reuse current time for rotation timestamp. */\r
 122     seconds = low = high = 0;\r
 123     SystemTimeToFileTime(&st, &info.ftLastWriteTime);\r
 124   }\r
 125 \r
 126   /* Check file age. */\r
 127   if (seconds) {\r
 128     FILETIME ft;\r
 129     SystemTimeToFileTime(&st, &ft);\r
 130 \r
 131     ULARGE_INTEGER s;\r
 132     s.LowPart = ft.dwLowDateTime;\r
 133     s.HighPart = ft.dwHighDateTime;\r
 134     s.QuadPart -= seconds * 10000000LL;\r
 135     ft.dwLowDateTime = s.LowPart;\r
 136     ft.dwHighDateTime = s.HighPart;\r
 137     if (CompareFileTime(&info.ftLastWriteTime, &ft) > 0) return;\r
 138   }\r
 139 \r
 140   /* Check file size. */\r
 141   if (low || high) {\r
 142     if (info.nFileSizeHigh < high) return;\r
 143     if (info.nFileSizeHigh == high && info.nFileSizeLow < low) return;\r
 144   }\r
 145 \r
 146   /* Get new filename. */\r
 147   FileTimeToSystemTime(&info.ftLastWriteTime, &st);\r
 148 \r
 149   TCHAR buffer[MAX_PATH];\r
 150   memmove(buffer, path, sizeof(buffer));\r
 151   TCHAR *ext = PathFindExtension(buffer);\r
 152   TCHAR extension[MAX_PATH];\r
 153   _sntprintf_s(extension, _countof(extension), _TRUNCATE, _T("-%04u%02u%02uT%02u%02u%02u.%03u%s"), st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds, ext);\r
 154   *ext = _T('\0');\r
 155   TCHAR rotated[MAX_PATH];\r
 156   _sntprintf_s(rotated, _countof(rotated), _TRUNCATE, _T("%s%s"), buffer, extension);\r
 157 \r
 158   /* Rotate. */\r
 159   if (MoveFile(path, rotated)) return;\r
 160   error = GetLastError();\r
 161 \r
 162   log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_ROTATE_FILE_FAILED, service_name, path, _T("MoveFile()"), rotated, error_string(error), 0);\r
 163   return;\r
 164 }\r
 165 \r
 166 int get_output_handles(nssm_service_t *service, HKEY key, STARTUPINFO *si) {\r
 167   bool set_flags = false;\r
 168 \r
 169   /* Standard security attributes allowing inheritance. */\r
 170   SECURITY_ATTRIBUTES attributes;\r
 171   ZeroMemory(&attributes, sizeof(attributes));\r
 172   attributes.bInheritHandle = true;\r
 173 \r
 174   /* stdin */\r
 175   if (get_createfile_parameters(key, NSSM_REG_STDIN, service->stdin_path, &service->stdin_sharing, NSSM_STDIN_SHARING, &service->stdin_disposition, NSSM_STDIN_DISPOSITION, &service->stdin_flags, NSSM_STDIN_FLAGS)) {\r
 176     service->stdin_sharing = service->stdin_disposition = service->stdin_flags = 0;\r
 177     ZeroMemory(service->stdin_path, _countof(service->stdin_path) * sizeof(TCHAR));\r
 178     return 1;\r
 179   }\r
 180   if (si && service->stdin_path[0]) {\r
 181     si->hStdInput = CreateFile(service->stdin_path, FILE_READ_DATA, service->stdin_sharing, &attributes, service->stdin_disposition, service->stdin_flags, 0);\r
 182     if (! si->hStdInput) {\r
 183       log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATEFILE_FAILED, service->stdin_path, error_string(GetLastError()), 0);\r
 184       return 2;\r
 185     }\r
 186     set_flags = true;\r
 187   }\r
 188 \r
 189   /* stdout */\r
 190   if (get_createfile_parameters(key, NSSM_REG_STDOUT, service->stdout_path, &service->stdout_sharing, NSSM_STDOUT_SHARING, &service->stdout_disposition, NSSM_STDOUT_DISPOSITION, &service->stdout_flags, NSSM_STDOUT_FLAGS)) {\r
 191     service->stdout_sharing = service->stdout_disposition = service->stdout_flags = 0;\r
 192     ZeroMemory(service->stdout_path, _countof(service->stdout_path) * sizeof(TCHAR));\r
 193     return 3;\r
 194   }\r
 195   if (si && service->stdout_path[0]) {\r
 196     if (service->rotate_files) rotate_file(service->name, service->stdout_path, service->rotate_seconds, service->rotate_bytes_low, service->rotate_bytes_high);\r
 197     si->hStdOutput = append_to_file(service->stdout_path, service->stdout_sharing, &attributes, service->stdout_disposition, service->stdout_flags);\r
 198     if (! si->hStdOutput) return 4;\r
 199     set_flags = true;\r
 200   }\r
 201 \r
 202   /* stderr */\r
 203   if (get_createfile_parameters(key, NSSM_REG_STDERR, service->stderr_path, &service->stdout_sharing, NSSM_STDERR_SHARING, &service->stdout_disposition, NSSM_STDERR_DISPOSITION, &service->stdout_flags, NSSM_STDERR_FLAGS)) {\r
 204     service->stderr_sharing = service->stderr_disposition = service->stderr_flags = 0;\r
 205     ZeroMemory(service->stderr_path, _countof(service->stderr_path) * sizeof(TCHAR));\r
 206     return 5;\r
 207   }\r
 208   if (service->stderr_path[0]) {\r
 209     /* Same as stdout? */\r
 210     if (str_equiv(service->stderr_path, service->stdout_path)) {\r
 211       service->stderr_sharing = service->stdout_sharing;\r
 212       service->stderr_disposition = service->stdout_disposition;\r
 213       service->stderr_flags = service->stdout_flags;\r
 214 \r
 215       if (si) {\r
 216         /* Two handles to the same file will create a race. */\r
 217         if (! DuplicateHandle(GetCurrentProcess(), si->hStdOutput, GetCurrentProcess(), &si->hStdError, 0, true, DUPLICATE_SAME_ACCESS)) {\r
 218           log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_DUPLICATEHANDLE_FAILED, NSSM_REG_STDOUT, error_string(GetLastError()), 0);\r
 219           return 6;\r
 220         }\r
 221       }\r
 222     }\r
 223     else if (si) {\r
 224       if (service->rotate_files) rotate_file(service->name, service->stderr_path, service->rotate_seconds, service->rotate_bytes_low, service->rotate_bytes_high);\r
 225       si->hStdError = append_to_file(service->stderr_path, service->stdout_sharing, &attributes, service->stdout_disposition, service->stdout_flags);\r
 226       if (! si->hStdError) {\r
 227         log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATEFILE_FAILED, service->stderr_path, error_string(GetLastError()), 0);\r
 228         return 7;\r
 229       }\r
 230       SetEndOfFile(si->hStdError);\r
 231     }\r
 232     set_flags = true;\r
 233   }\r
 234 \r
 235   if (! set_flags) return 0;\r
 236 \r
 237   /*\r
 238     We need to set the startup_info flags to make the new handles\r
 239     inheritable by the new process.\r
 240   */\r
 241   if (si) si->dwFlags |= STARTF_USESTDHANDLES;\r
 242 \r
 243   return 0;\r
 244 }\r
 245 \r
 246 void close_output_handles(STARTUPINFO *si) {\r
 247   if (si->hStdInput) CloseHandle(si->hStdInput);\r
 248   if (si->hStdOutput) CloseHandle(si->hStdOutput);\r
 249   if (si->hStdError) CloseHandle(si->hStdError);\r
 250 }\r