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 HANDLE append_to_file(TCHAR *path, unsigned long sharing, SECURITY_ATTRIBUTES *attributes, unsigned long disposition, unsigned long flags) {\r
  65   HANDLE ret;\r
  66 \r
  67   /* Try to append to the file first. */\r
  68   ret = CreateFile(path, FILE_APPEND_DATA, sharing, attributes, disposition, flags, 0);\r
  69   if (ret) {\r
  70     SetEndOfFile(ret);\r
  71     return ret;\r
  72   }\r
  73 \r
  74   unsigned long error = GetLastError();\r
  75   if (error != ERROR_FILE_NOT_FOUND) {\r
  76     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATEFILE_FAILED, path, error_string(error), 0);\r
  77     return (HANDLE) 0;\r
  78   }\r
  79 \r
  80   /* It didn't exist.  Create it. */\r
  81   return CreateFile(path, FILE_WRITE_DATA, sharing, attributes, disposition, flags, 0);\r
  82 }\r
  83 \r
  84 void rotate_file(TCHAR *service_name, TCHAR *path, unsigned long seconds, unsigned long low, unsigned long high) {\r
  85   unsigned long error;\r
  86 \r
  87   /* Now. */\r
  88   SYSTEMTIME st;\r
  89   GetSystemTime(&st);\r
  90 \r
  91   BY_HANDLE_FILE_INFORMATION info;\r
  92 \r
  93   /* Try to open the file to check if it exists and to get attributes. */\r
  94   HANDLE file = CreateFile(path, 0, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);\r
  95   if (file) {\r
  96     /* Get file attributes. */\r
  97     if (! GetFileInformationByHandle(file, &info)) {\r
  98       /* Reuse current time for rotation timestamp. */\r
  99       seconds = low = high = 0;\r
 100       SystemTimeToFileTime(&st, &info.ftLastWriteTime);\r
 101     }\r
 102 \r
 103     CloseHandle(file);\r
 104   }\r
 105   else {\r
 106     error = GetLastError();\r
 107     if (error == ERROR_FILE_NOT_FOUND) return;\r
 108     log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_ROTATE_FILE_FAILED, service_name, path, _T("CreateFile()"), path, error_string(error), 0);\r
 109     /* Reuse current time for rotation timestamp. */\r
 110     seconds = low = high = 0;\r
 111     SystemTimeToFileTime(&st, &info.ftLastWriteTime);\r
 112   }\r
 113 \r
 114   /* Check file age. */\r
 115   if (seconds) {\r
 116     FILETIME ft;\r
 117     SystemTimeToFileTime(&st, &ft);\r
 118 \r
 119     ULARGE_INTEGER s;\r
 120     s.LowPart = ft.dwLowDateTime;\r
 121     s.HighPart = ft.dwHighDateTime;\r
 122     s.QuadPart -= seconds * 10000000LL;\r
 123     ft.dwLowDateTime = s.LowPart;\r
 124     ft.dwHighDateTime = s.HighPart;\r
 125     if (CompareFileTime(&info.ftLastWriteTime, &ft) > 0) return;\r
 126   }\r
 127 \r
 128   /* Check file size. */\r
 129   if (low || high) {\r
 130     if (info.nFileSizeHigh < high) return;\r
 131     if (info.nFileSizeHigh == high && info.nFileSizeLow < low) return;\r
 132   }\r
 133 \r
 134   /* Get new filename. */\r
 135   FileTimeToSystemTime(&info.ftLastWriteTime, &st);\r
 136 \r
 137   TCHAR buffer[MAX_PATH];\r
 138   memmove(buffer, path, sizeof(buffer));\r
 139   TCHAR *ext = PathFindExtension(buffer);\r
 140   TCHAR extension[MAX_PATH];\r
 141   _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
 142   *ext = _T('\0');\r
 143   TCHAR rotated[MAX_PATH];\r
 144   _sntprintf_s(rotated, _countof(rotated), _TRUNCATE, _T("%s%s"), buffer, extension);\r
 145 \r
 146   /* Rotate. */\r
 147   if (MoveFile(path, rotated)) return;\r
 148   error = GetLastError();\r
 149 \r
 150   log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_ROTATE_FILE_FAILED, service_name, path, _T("MoveFile()"), rotated, error_string(error), 0);\r
 151   return;\r
 152 }\r
 153 \r
 154 int get_output_handles(nssm_service_t *service, HKEY key, STARTUPINFO *si) {\r
 155   bool set_flags = false;\r
 156 \r
 157   /* Standard security attributes allowing inheritance. */\r
 158   SECURITY_ATTRIBUTES attributes;\r
 159   ZeroMemory(&attributes, sizeof(attributes));\r
 160   attributes.bInheritHandle = true;\r
 161 \r
 162   /* stdin */\r
 163   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
 164     service->stdin_sharing = service->stdin_disposition = service->stdin_flags = 0;\r
 165     ZeroMemory(service->stdin_path, _countof(service->stdin_path) * sizeof(TCHAR));\r
 166     return 1;\r
 167   }\r
 168   if (si && service->stdin_path[0]) {\r
 169     si->hStdInput = CreateFile(service->stdin_path, FILE_READ_DATA, service->stdin_sharing, &attributes, service->stdin_disposition, service->stdin_flags, 0);\r
 170     if (! si->hStdInput) {\r
 171       log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATEFILE_FAILED, service->stdin_path, error_string(GetLastError()), 0);\r
 172       return 2;\r
 173     }\r
 174     set_flags = true;\r
 175   }\r
 176 \r
 177   /* stdout */\r
 178   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
 179     service->stdout_sharing = service->stdout_disposition = service->stdout_flags = 0;\r
 180     ZeroMemory(service->stdout_path, _countof(service->stdout_path) * sizeof(TCHAR));\r
 181     return 3;\r
 182   }\r
 183   if (si && service->stdout_path[0]) {\r
 184     if (service->rotate_files) rotate_file(service->name, service->stdout_path, service->rotate_seconds, service->rotate_bytes_low, service->rotate_bytes_high);\r
 185     si->hStdOutput = append_to_file(service->stdout_path, service->stdout_sharing, &attributes, service->stdout_disposition, service->stdout_flags);\r
 186     if (! si->hStdOutput) return 4;\r
 187     set_flags = true;\r
 188   }\r
 189 \r
 190   /* stderr */\r
 191   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
 192     service->stderr_sharing = service->stderr_disposition = service->stderr_flags = 0;\r
 193     ZeroMemory(service->stderr_path, _countof(service->stderr_path) * sizeof(TCHAR));\r
 194     return 5;\r
 195   }\r
 196   if (service->stderr_path[0]) {\r
 197     /* Same as stdout? */\r
 198     if (str_equiv(service->stderr_path, service->stdout_path)) {\r
 199       service->stderr_sharing = service->stdout_sharing;\r
 200       service->stderr_disposition = service->stdout_disposition;\r
 201       service->stderr_flags = service->stdout_flags;\r
 202 \r
 203       if (si) {\r
 204         /* Two handles to the same file will create a race. */\r
 205         if (! DuplicateHandle(GetCurrentProcess(), si->hStdOutput, GetCurrentProcess(), &si->hStdError, 0, true, DUPLICATE_SAME_ACCESS)) {\r
 206           log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_DUPLICATEHANDLE_FAILED, NSSM_REG_STDOUT, error_string(GetLastError()), 0);\r
 207           return 6;\r
 208         }\r
 209       }\r
 210     }\r
 211     else if (si) {\r
 212       if (service->rotate_files) rotate_file(service->name, service->stderr_path, service->rotate_seconds, service->rotate_bytes_low, service->rotate_bytes_high);\r
 213       si->hStdError = append_to_file(service->stderr_path, service->stdout_sharing, &attributes, service->stdout_disposition, service->stdout_flags);\r
 214       if (! si->hStdError) {\r
 215         log_event(EVENTLOG_ERROR_TYPE, NSSM_EVENT_CREATEFILE_FAILED, service->stderr_path, error_string(GetLastError()), 0);\r
 216         return 7;\r
 217       }\r
 218       SetEndOfFile(si->hStdError);\r
 219     }\r
 220     set_flags = true;\r
 221   }\r
 222 \r
 223   if (! set_flags) return 0;\r
 224 \r
 225   /*\r
 226     We need to set the startup_info flags to make the new handles\r
 227     inheritable by the new process.\r
 228   */\r
 229   if (si) si->dwFlags |= STARTF_USESTDHANDLES;\r
 230 \r
 231   return 0;\r
 232 }\r
 233 \r
 234 void close_output_handles(STARTUPINFO *si) {\r
 235   if (si->hStdInput) CloseHandle(si->hStdInput);\r
 236   if (si->hStdOutput) CloseHandle(si->hStdOutput);\r
 237   if (si->hStdError) CloseHandle(si->hStdError);\r
 238 }\r