framework/TWPSerDaemon.c

   1 /*
   2     Copyright (c) 2014, McAfee, Inc.
   3
   4     All rights reserved.
   5
   6     Redistribution and use in source and binary forms, with or without modification,
   7     are permitted provided that the following conditions are met:
   8
   9     Redistributions of source code must retain the above copyright notice, this list
  10     of conditions and the following disclaimer.
  11
  12     Redistributions in binary form must reproduce the above copyright notice, this
  13     list of conditions and the following disclaimer in the documentation and/or other
  14     materials provided with the distribution.
  15
  16     Neither the name of McAfee, Inc. nor the names of its contributors may be used
  17     to endorse or promote products derived from this software without specific prior
  18     written permission.
  19
  20     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  21     ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  22     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  23     IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  24     INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  25     BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26     DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  27     LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  28     OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  29     OF THE POSSIBILITY OF SUCH DAMAGE.
  30 */
  31
  32 /**
  33  * \file TWPSerDaemon.c
  34  * \brief TWP Service Daemon source file.
  35  *
  36  * This file implements the TWP Service Daemon functions used by Security framework.
  37  */
  38
  39 #include <malloc.h>
  40 #include <signal.h>
  41 #include <stdio.h>
  42 #include <string.h>
  43
  44 #include "Debug.h"
  45 #include "IpcForkDaemon.h"
  46 #include "TWPImpl.h"
  47 #include "TWPSerDaemon.h"
  48
  49 #define RISK_LEVEL_LEN 2
  50 #define RETURN_STATUS_STR_LEN 4
  51
  52 int
  53 TWPSerGetVersion(void *pData, int req_argc, char **req_argv, char ***rep_argv, int *rep_argc,
  54                    CALLBACKFUNC callback, TSC_METHOD_HANDLE *handle)
  55 {
  56     // Opens TWP Framework library.
  57     TWPAPIInit Init;
  58     TWPLIB_HANDLE hLib;
  59
  60     Init.api_version = TWPAPI_VERSION;
  61     Init.memallocfunc = (TWPFnMemAlloc) malloc;
  62     Init.memfreefunc = free;
  63     hLib = TWPInitLibrary(&Init);
  64
  65     *rep_argc = 1;
  66     *rep_argv = NULL;
  67
  68     TWP_RESULT iRes;
  69     char *szRes = NULL;
  70
  71     if (hLib == INVALID_TWPLIB_HANDLE)
  72     {
  73         iRes = TWP_INVALID_HANDLE;
  74         goto close_library;
  75     }
  76
  77     // Get the Version Information of TWP Framework.
  78     TWPVerInfo VerInfo;
  79     iRes = TWPGetVersion(hLib, &VerInfo);
  80
  81     // Check if TWPGetVersion call returned TWP_SUCCESS.
  82     if (iRes != TWP_SUCCESS)
  83     {
  84         DERR("%s", "TWPGetVersion did not return TWP_SUCCESS\n");
  85     }
  86     else
  87     {
  88         DINFO("TWPGetVersion returns = %s %s\n", VerInfo.szFrameworkVer, VerInfo.szPluginVer);
  89
  90         char *szRepArgv1 = strdup(VerInfo.szFrameworkVer);
  91         char *szRepArgv2 = strdup(VerInfo.szPluginVer);
  92         char *szRepArgv3 = strdup(TWP_DAEMON_VERSION);
  93
  94         if (szRepArgv1 == NULL || szRepArgv2 == NULL || szRepArgv3 == NULL)
  95         {
  96             DERR("%s", "strdup fails to allocate mem for version info");
  97
  98             free(szRepArgv1);
  99             free(szRepArgv2);
 100             free(szRepArgv3);
 101             iRes = TWP_NOMEM;
 102             goto close_library;
 103         }
 104
 105         *rep_argc = 4;
 106         *rep_argv = (char **) malloc(sizeof(char*) * (*rep_argc));
 107
 108         if (*rep_argv == NULL)
 109         {
 110             DERR("%s", "malloc returns Error for reply pointer array\n");
 111
 112             free(szRepArgv1);
 113             free(szRepArgv2);
 114             free(szRepArgv3);
 115             *rep_argc = 1;
 116             iRes = TWP_NOMEM;
 117             goto close_library;
 118         }
 119
 120         (*rep_argv)[1] = szRepArgv1;
 121         (*rep_argv)[2] = szRepArgv2;
 122         (*rep_argv)[3] = szRepArgv3;
 123     }
 124
 125 close_library:
 126     // Compose the return value.
 127     // Convert iRes to String.
 128     szRes = (char *) malloc(sizeof(char) * RETURN_STATUS_STR_LEN);
 129     if (szRes == NULL)
 130     {
 131         DERR("%s", "malloc returns error\n");
 132         goto err;
 133     }
 134     snprintf(szRes, RETURN_STATUS_STR_LEN, "%d", iRes);
 135
 136     if (*rep_argc == 1)
 137     {
 138         *rep_argv = (char **) malloc (sizeof(char*) * 1);
 139         if (*rep_argv == NULL)
 140             goto err;
 141     }
 142
 143     //Assign result code.
 144     (*rep_argv)[0] = szRes;
 145
 146     TWPUninitLibrary(hLib);
 147     return 0;
 148
 149 err:
 150     if (*rep_argv != NULL)
 151     {
 152         free((*rep_argv)[1]);
 153         free((*rep_argv)[2]);
 154         free((*rep_argv)[3]);
 155     }
 156     *rep_argc = 0;
 157     free(*rep_argv);
 158     *rep_argv = NULL;
 159     rep_argv = NULL;
 160     free(szRes);
 161     TWPUninitLibrary(hLib);
 162
 163     return -1;
 164 }
 165
 166 int
 167 TWPSerGetURLReputation(void *pData, int req_argc, char **req_argv, char ***rep_argv, int *rep_argc,
 168                    CALLBACKFUNC callback, TSC_METHOD_HANDLE *handle)
 169 {
 170     // open TWP framework library
 171     TWPAPIInit Init;
 172     TWPLIB_HANDLE hLib;
 173
 174     Init.api_version = TWPAPI_VERSION;
 175     Init.memallocfunc = (TWPFnMemAlloc) malloc;
 176     Init.memfreefunc = free;
 177     hLib = TWPInitLibrary(&Init);
 178
 179     *rep_argc = 1;
 180     *rep_argv = NULL;
 181
 182     TWP_RESULT iRes;
 183     char *szRes = NULL;
 184
 185     if (hLib == INVALID_TWPLIB_HANDLE)
 186     {
 187         iRes = TWP_INVALID_HANDLE;
 188         goto close_library;
 189     }
 190
 191     // Get Risk Level.
 192     int iRiskLevel;
 193     unsigned int uBlkUrlLen;
 194     char *pBlkUrl = NULL;
 195
 196     // Check for Risk Level of URL.
 197     iRes = TWPCheckURL(hLib, req_argv[0], &pBlkUrl, &uBlkUrlLen, &iRiskLevel);
 198
 199     // Check if TWPCheckURL call returned TWP_SUCCESS.
 200     if (iRes != TWP_SUCCESS)
 201     {
 202         DERR("%s : %s\n", "TWPCheckURL returned Error", req_argv[0]);
 203     }
 204     else
 205     {
 206         DINFO("TWPCheckURL returns risk level = %d\n", iRiskLevel);
 207
 208         // convert RiskLevel integer to string
 209         char *szRiskLevel;
 210         szRiskLevel = (char *) malloc(sizeof(char) * RISK_LEVEL_LEN);
 211         if (szRiskLevel == NULL)
 212         {
 213             DINFO("%s", "malloc returns error\n");
 214             iRes = TWP_NOMEM;
 215             goto close_library;
 216         }
 217         snprintf(szRiskLevel, RISK_LEVEL_LEN, "%d", iRiskLevel);
 218
 219         *rep_argc = 2;
 220         *rep_argv = (char **) malloc(sizeof(char*) * (*rep_argc));
 221         if (*rep_argv == NULL)
 222         {
 223             DINFO("%s", "realloc returns Error for reply pointer array\n");
 224             free(szRiskLevel);
 225             *rep_argc = 1;
 226             iRes = TWP_NOMEM;
 227             goto close_library;
 228         }
 229
 230         //Assign Risk Level
 231         (*rep_argv)[1] = szRiskLevel;
 232
 233         // Assign redirect url if RiskLevel is greater than or equal to TWP_Medium
 234         if (iRiskLevel >= TWP_Medium)
 235         {
 236             *rep_argc = 3;
 237             *rep_argv = (char **) realloc(*rep_argv, sizeof(char*) * (*rep_argc));
 238             if (*rep_argv == NULL)
 239             {
 240                 DINFO("%s", "realloc returns Error for reply pointer array\n");
 241                 free(szRiskLevel);
 242                 *rep_argc = 1;
 243                 iRes = TWP_NOMEM;
 244                 goto close_library;
 245             }
 246             (*rep_argv)[2] = pBlkUrl;
 247         }
 248     }
 249
 250 close_library:
 251     // Compose the return value.
 252     // Convert iRes to String.
 253     szRes = (char *) malloc(sizeof(char) * RETURN_STATUS_STR_LEN);
 254     if (szRes == NULL)
 255     {
 256         DERR("%s", "malloc returns error\n");
 257         goto err;
 258     }
 259     snprintf(szRes, RETURN_STATUS_STR_LEN, "%d", iRes);
 260
 261     if (*rep_argc == 1)
 262     {
 263         *rep_argv = (char **) malloc (sizeof(char*) * 1);
 264         if (*rep_argv == NULL)
 265             goto err;
 266     }
 267     //Assign Result code
 268     (*rep_argv)[0] = szRes;
 269
 270     TWPUninitLibrary(hLib);
 271     return 0;
 272
 273 err:
 274     if (*rep_argv != NULL)
 275     {
 276         free((*rep_argv)[1]);
 277         free((*rep_argv)[2]);
 278     }
 279     *rep_argc = 0;
 280     free(*rep_argv);
 281     *rep_argv = NULL;
 282     rep_argv = NULL;
 283     free(szRes);
 284     TWPUninitLibrary(hLib);
 285     return -1;
 286 }
 287
 288 int
 289 main(int argc, char **argv)
 290 {
 291 #ifndef DEBUG
 292     fork_daemon();
 293 #endif
 294
 295     TSC_SERVER_HANDLE hServer;
 296
 297     if ((hServer = IpcServerOpen(TSC_DBUS_SERVER_WP_CHANNEL)) != NULL)
 298     {
 299         DINFO("%s", "successfully opened server \n");
 300
 301         // Register methods for get url reputation
 302         IpcServerMethod method_1;
 303         snprintf(method_1.szMethod, sizeof(method_1.szMethod), "%s", "TWPSerGetURLReputation");
 304         method_1.method = (METHODFUNC) TWPSerGetURLReputation;
 305         method_1.pData = NULL;
 306
 307         if (IpcServerAddMethod(hServer, &method_1) != 0)
 308         {
 309             DERR("%s", "unable to add method TWPSerGetURLReputation\n");
 310             goto close_server;
 311         }
 312
 313         // Register methods for getversion
 314         IpcServerMethod method_2;
 315         snprintf(method_2.szMethod, sizeof(method_2.szMethod), "%s", "TWPSerGetVersion");
 316         method_2.method = (METHODFUNC) TWPSerGetVersion;
 317         method_2.pData = NULL;
 318
 319         if (IpcServerAddMethod(hServer, &method_2) != 0)
 320         {
 321             DERR("%s", "unable to add method TWPSerGetVersion\n");
 322             goto close_server;
 323         }
 324
 325         // Daemon waits here for request from clients.
 326         IpcServerMainLoop(hServer);
 327
 328         IpcServerClose(&hServer);
 329     }
 330     else
 331     {
 332         DFATAL("%s", "unable to open server connection \n");
 333         goto err;
 334     }
 335
 336     return 0;
 337
 338 close_server:
 339     IpcServerClose(&hServer);
 340
 341 err:
 342     DFATAL("%s", "Unable to start the Daemon \n");
 343     return -1;
 344 }