git.oblomov.eu Git - wine/blob - programs/net/net.c

   1 /*
   2  * Copyright 2007 Tim Schwartz
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <windows.h>
  22 #include <lm.h>
  23 #include "resources.h"
  24
  25 #define NET_START 0001
  26 #define NET_STOP  0002
  27
  28 static int output_string(int msg, ...)
  29 {
  30     char msg_buffer[8192];
  31     va_list arguments;
  32
  33     LoadStringA(GetModuleHandleW(NULL), msg, msg_buffer, sizeof(msg_buffer));
  34     va_start(arguments, msg);
  35     vprintf(msg_buffer, arguments);
  36     va_end(arguments);
  37     return 0;
  38 }
  39
  40 static BOOL output_error_string(DWORD error)
  41 {
  42     LPSTR pBuffer;
  43     if (FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM |
  44             FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_ALLOCATE_BUFFER,
  45             NULL, error, 0, (LPSTR)&pBuffer, 0, NULL))
  46     {
  47         fputs(pBuffer, stdout);
  48         LocalFree(pBuffer);
  49         return TRUE;
  50     }
  51     return FALSE;
  52 }
  53
  54 static BOOL net_use(int argc, char *argv[])
  55 {
  56     USE_INFO_2 *buffer, *connection;
  57     DWORD read, total, resume_handle, rc, i;
  58     char *status[STRING_RECONN-STRING_OK+1];
  59     resume_handle = 0;
  60     buffer = NULL;
  61
  62     if(argc<3)
  63     {
  64         HMODULE hmod = GetModuleHandleW(NULL);
  65
  66         /* Load the status strings */
  67         for (i = 0; i < sizeof(status)/sizeof(*status); i++)
  68         {
  69             status[i] = HeapAlloc(GetProcessHeap(), 0, 1024);
  70             LoadStringA(hmod, STRING_OK+i, status[i], 1024);
  71         }
  72
  73         do {
  74             rc = NetUseEnum(NULL, 2, (BYTE **) &buffer, 2048, &read, &total, &resume_handle);
  75             if (rc != ERROR_MORE_DATA && rc != ERROR_SUCCESS)
  76             {
  77                 break;
  78             }
  79
  80             if(total == 0)
  81             {
  82                 output_string(STRING_NO_ENTRIES);
  83                 break;
  84             }
  85
  86             output_string(STRING_USE_HEADER);
  87             for (i = 0, connection = buffer; i < read; ++i, ++connection)
  88                 output_string(STRING_USE_ENTRY, status[connection->ui2_status], connection->ui2_local,
  89                                 connection->ui2_remote, connection->ui2_refcount);
  90
  91             if (buffer != NULL) NetApiBufferFree(buffer);
  92         } while (rc == ERROR_MORE_DATA);
  93
  94         /* Release the status strings */
  95         for (i = 0; i < sizeof(status)/sizeof(*status); i++)
  96             HeapFree(GetProcessHeap(), 0, status[i]);
  97
  98         return TRUE;
  99     }
 100
 101     return FALSE;
 102 }
 103
 104 static BOOL StopService(SC_HANDLE SCManager, SC_HANDLE serviceHandle)
 105 {
 106     LPENUM_SERVICE_STATUSW dependencies = NULL;
 107     DWORD buffer_size = 0;
 108     DWORD count = 0, counter;
 109     BOOL result;
 110     SC_HANDLE dependent_serviceHandle;
 111     SERVICE_STATUS_PROCESS ssp;
 112
 113     result = EnumDependentServicesW(serviceHandle, SERVICE_ACTIVE, dependencies, buffer_size, &buffer_size, &count);
 114
 115     if(!result && (GetLastError() == ERROR_MORE_DATA))
 116     {
 117         dependencies = HeapAlloc(GetProcessHeap(), 0, buffer_size);
 118         if(EnumDependentServicesW(serviceHandle, SERVICE_ACTIVE, dependencies, buffer_size, &buffer_size, &count))
 119         {
 120             for(counter = 0; counter < count; counter++)
 121             {
 122                 output_string(STRING_STOP_DEP, dependencies[counter].lpDisplayName);
 123                 dependent_serviceHandle = OpenServiceW(SCManager, dependencies[counter].lpServiceName, SC_MANAGER_ALL_ACCESS);
 124                 if(dependent_serviceHandle) result = StopService(SCManager, dependent_serviceHandle);
 125                 CloseServiceHandle(dependent_serviceHandle);
 126                 if(!result) output_string(STRING_CANT_STOP, dependencies[counter].lpDisplayName);
 127            }
 128         }
 129     }
 130
 131     if(result) result = ControlService(serviceHandle, SERVICE_CONTROL_STOP, (LPSERVICE_STATUS)&ssp);
 132     HeapFree(GetProcessHeap(), 0, dependencies);
 133     return result;
 134 }
 135
 136 static BOOL net_service(int operation, char *service_name)
 137 {
 138     SC_HANDLE SCManager, serviceHandle;
 139     BOOL result = 0;
 140     char service_display_name[4096];
 141     DWORD buffer_size = sizeof(service_display_name);
 142
 143     SCManager = OpenSCManagerW(NULL, NULL, SC_MANAGER_ALL_ACCESS);
 144     if(!SCManager)
 145     {
 146         output_string(STRING_NO_SCM);
 147         return FALSE;
 148     }
 149     serviceHandle = OpenServiceA(SCManager, service_name, SC_MANAGER_ALL_ACCESS);
 150     if(!serviceHandle)
 151     {
 152         output_string(STRING_NO_SVCHANDLE);
 153         CloseServiceHandle(SCManager);
 154         return FALSE;
 155     }
 156
 157
 158     GetServiceDisplayNameA(SCManager, service_name, service_display_name, &buffer_size);
 159     if (!service_display_name[0]) strcpy(service_display_name, service_name);
 160
 161     switch(operation)
 162     {
 163     case NET_START:
 164         output_string(STRING_START_SVC, service_display_name);
 165         result = StartServiceW(serviceHandle, 0, NULL);
 166
 167         if(result) output_string(STRING_START_SVC_SUCCESS, service_display_name);
 168         else
 169         {
 170             if (!output_error_string(GetLastError()))
 171                 output_string(STRING_START_SVC_FAIL, service_display_name);
 172         }
 173         break;
 174     case NET_STOP:
 175         output_string(STRING_STOP_SVC, service_display_name);
 176         result = StopService(SCManager, serviceHandle);
 177
 178         if(result) output_string(STRING_STOP_SVC_SUCCESS, service_display_name);
 179         else
 180         {
 181             if (!output_error_string(GetLastError()))
 182                 output_string(STRING_STOP_SVC_FAIL, service_display_name);
 183         }
 184         break;
 185     }
 186
 187     CloseServiceHandle(serviceHandle);
 188     CloseServiceHandle(SCManager);
 189     return result;
 190 }
 191
 192 int main(int argc, char *argv[])
 193 {
 194     if (argc < 2)
 195     {
 196         output_string(STRING_USAGE);
 197         return 1;
 198     }
 199
 200     if(!strcasecmp(argv[1], "help"))
 201     {
 202         output_string(STRING_HELP_USAGE);
 203     }
 204
 205     if(!strcasecmp(argv[1], "start"))
 206     {
 207         if(argc < 3)
 208         {
 209             output_string(STRING_START_USAGE);
 210             return 1;
 211         }
 212
 213         if(!net_service(NET_START, argv[2]))
 214         {
 215             return 1;
 216         }
 217         return 0;
 218     }
 219
 220     if(!strcasecmp(argv[1], "stop"))
 221     {
 222         if(argc < 3)
 223         {
 224             output_string(STRING_STOP_USAGE);
 225             return 1;
 226         }
 227
 228         if(!net_service(NET_STOP, argv[2]))
 229         {
 230             return 1;
 231         }
 232         return 0;
 233     }
 234
 235     if(!strcasecmp(argv[1], "use"))
 236     {
 237         if(!net_use(argc, argv)) return 1;
 238     }
 239
 240     return 0;
 241 }