CodeCompass

1
#include <stdlib.h>
2
#include <assert.h>
3

4
#include "ldlogger-tool.h"
5

6
#define PROG_LIST_SEPARATOR ":"
7

8
extern char** environ;
9

10
/**
11
 * Reads a colon separated list from the given environment variable and tries
12
 * to match to the given program name. If one program matches (from the list)
13
 * to the given program name, then it will return a non zero value.
14
 *
15
 * On any error or mismatch the function returns 0.
16
 *
17
 * @param envVar_ the name of environment variable.
18
 * @param progName_ program name to match.
19
 * @return non zero on match, 0 otherwise
20
 */
21
static int matchToProgramList(
22
  const char* envVar_,
23
  const char* progName_)
24
{
25
  char* progList;
26
  char* token;
27
  const char* progListVar = getenv(envVar_);
28
  if (!progListVar)
29
  {
30
    return 0;
31
  }
32

33
  progList = loggerStrDup(progListVar);
34
  if (!progList)
35
  {
36
    return 0;
37
  }
38

39
  token = strtok(progList, PROG_LIST_SEPARATOR);
40
  while (token)
41
  {
42
    if (strstr(progName_, token))
43
    {
44
      /* Match! */
45
      free(progList);
46
      return 1;
47
    }
48

49
    token = strtok(NULL, PROG_LIST_SEPARATOR);
50
  }
51

52
  free(progList);
53
  return 0;
54
}
55

56
/**
57
 *  Disable / enable recursive logging.
58
 */
59
static void turnLogging(int on)
60
{
61
  int i;
62
  for (i = 0; environ[i]; ++i)
63
  {
64
    if (strstr(environ[i], "LD_PRELOAD="))
65
    {
66
       environ[i][0] = on ? 'L' : 'X';
67
    }
68
  }
69
}
70

71
LoggerFile* loggerFileInitFromPath(LoggerFile* file_, const char* path_)
72
{
73
  assert(file_ && "file_ must be not NULL!");
74

75
  if (!loggerMakePathAbs(path_, file_->path, 0))
76
  {
77
    /* fallback to the given path */
78
    strcpy(file_->path, path_);
79
  }
80

81
  return file_;
82
}
83

84
LoggerAction* loggerActionNew(char const* toolName_)
85
{
86
  LoggerAction* act = (LoggerAction*) malloc(sizeof(LoggerAction));
87
  if (!act)
88
  {
89
    return NULL;
90
  }
91

92
  loggerFileInitFromPath(&act->output, "./_noobj");
93
  loggerVectorInit(&act->arguments);
94
  loggerVectorInit(&act->sources);
95
  strcpy(act->toolName, toolName_);
96

97
  return act;
98
}
99

100
void loggerActionFree(LoggerAction* act_)
101
{
102
  if (!act_)
103
  {
104
    return;
105
  }
106

107
  loggerVectorClear(&act_->arguments);
108
  loggerVectorClear(&act_->sources);
109
  free(act_);
110
}
111

112
int loggerCollectActionsByProgName(
113
  const char* prog_,
114
  const char* const argv_[],
115
  LoggerVector* actions_)
116
{
117
  const char* toolName = strrchr(prog_, '/');
118
  if (toolName)
119
  {
120
    /* It was a path -> now its a program name */
121
    ++toolName;
122
  }
123
  else
124
  {
125
    /* Its a program name */
126
    toolName = prog_;
127
  }
128

129
  if (matchToProgramList("CC_LOGGER_GCC_LIKE", toolName))
130
  {
131
    int ret;
132
    turnLogging(0);
133
    ret = loggerGccParserCollectActions(prog_, toolName, argv_, actions_);
134
    turnLogging(1);
135
    return ret;
136
  }
137
  else if (matchToProgramList("CC_LOGGER_JAVAC_LIKE", toolName))
138
  {
139
    return loggerJavacParserCollectActions(prog_, toolName, argv_, actions_);
140
  }
141

142
  return 0;
143
}
144