← Back to branch summary

~ps10gel/ubuntu/xenial/trafficserver/6.2.0

« back to all changes in this revision

Viewing changes to proxy/mgmt2/api2/CfgContextImpl.cc

  • Committer: Bazaar Package Importer
  • Author(s): Arno Toell
  • Date: 2011-01-13 11:49:18 UTC
  • Revision ID: james.westby@ubuntu.com-20110113114918-vu422h8dknrgkj15
Tags: upstream-2.1.5-unstable
Import upstream version 2.1.5-unstable

Show diffs side-by-side

added added

removed removed

Lines of Context:
proxy/mgmt2/api2/CfgContextImpl.cc
 
1
/** @file
 
2
 
 
3
  A brief file description
 
4
 
 
5
  @section license License
 
6
 
 
7
  Licensed to the Apache Software Foundation (ASF) under one
 
8
  or more contributor license agreements.  See the NOTICE file
 
9
  distributed with this work for additional information
 
10
  regarding copyright ownership.  The ASF licenses this file
 
11
  to you under the Apache License, Version 2.0 (the
 
12
  "License"); you may not use this file except in compliance
 
13
  with the License.  You may obtain a copy of the License at
 
14
 
 
15
      http://www.apache.org/licenses/LICENSE-2.0
 
16
 
 
17
  Unless required by applicable law or agreed to in writing, software
 
18
  distributed under the License is distributed on an "AS IS" BASIS,
 
19
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
20
  See the License for the specific language governing permissions and
 
21
  limitations under the License.
 
22
 */
 
23
 
 
24
/***********************************************************************
 
25
 * CfgContextImpl.cc
 
26
 *
 
27
 * Implementation of CfgContext class and all the CfgEleObj subclasses
 
28
 ***********************************************************************/
 
29
 
 
30
#include "libts.h"
 
31
#include "ink_platform.h"
 
32
 
 
33
#include "CfgContextImpl.h"
 
34
#include "CfgContextUtils.h"
 
35
#include "INKMgmtAPI.h"
 
36
 
 
37
//--------------------------------------------------------------------------
 
38
// Defines
 
39
//--------------------------------------------------------------------------
 
40
 
 
41
#define TIGHT_RULE_CHECK true
 
42
 
 
43
//--------------------------------------------------------------------------
 
44
// CommentObj
 
45
//--------------------------------------------------------------------------
 
46
CommentObj::CommentObj(char *comment)
 
47
{
 
48
  m_ele = comment_ele_create(comment);
 
49
  m_valid = (comment ? true : false);
 
50
}
 
51
 
 
52
CommentObj::~CommentObj()
 
53
{
 
54
  comment_ele_destroy(m_ele);
 
55
}
 
56
 
 
57
char *
 
58
CommentObj::formatEleToRule()
 
59
{
 
60
  return xstrdup(m_ele->comment);
 
61
}
 
62
 
 
63
bool CommentObj::isValid()
 
64
{
 
65
  return m_valid;
 
66
}
 
67
 
 
68
INKCfgEle *
 
69
CommentObj::getCfgEleCopy()
 
70
{
 
71
  return (INKCfgEle *) copy_comment_ele(m_ele);
 
72
}
 
73
 
 
74
//--------------------------------------------------------------------------
 
75
// AdminAccessObj
 
76
//--------------------------------------------------------------------------
 
77
AdminAccessObj::AdminAccessObj(INKAdminAccessEle * ele)
 
78
{
 
79
  m_ele = ele;
 
80
  m_valid = true;
 
81
  m_valid = isValid();
 
82
}
 
83
 
 
84
AdminAccessObj::AdminAccessObj(TokenList * tokens)
 
85
{
 
86
  Token *tok;
 
87
  int accessType;
 
88
 
 
89
  m_ele = INKAdminAccessEleCreate();
 
90
  m_ele->cfg_ele.error = INK_ERR_OKAY;
 
91
  m_valid = true;
 
92
 
 
93
  if (!tokens || tokens->length < 3) {
 
94
    goto FORMAT_ERR;
 
95
  }
 
96
 
 
97
  m_ele->cfg_ele.type = get_rule_type(tokens, INK_FNAME_ADMIN_ACCESS);
 
98
  if (m_ele->cfg_ele.type == INK_TYPE_UNDEFINED) {
 
99
    goto FORMAT_ERR;
 
100
  }
 
101
  // The first token
 
102
  tok = tokens->first();
 
103
#ifdef TIGHT_RULE_CHECK
 
104
  if (tok->value)
 
105
    goto FORMAT_ERR;
 
106
#endif
 
107
  m_ele->user = xstrdup(tok->name);
 
108
 
 
109
  // The second token
 
110
  tok = tokens->next(tok);
 
111
#ifdef TIGHT_RULE_CHECK
 
112
  if (tok->value)
 
113
    goto FORMAT_ERR;
 
114
#endif
 
115
  m_ele->password = xstrdup(tok->name);
 
116
 
 
117
  // The third (last) token
 
118
  tok = tokens->next(tok);
 
119
#ifdef TIGHT_RULE_CHECK
 
120
  if (tok->value)
 
121
    goto FORMAT_ERR;
 
122
#endif
 
123
  accessType = ink_atoi(tok->name);
 
124
  switch (accessType) {
 
125
  case 0:
 
126
    m_ele->access = INK_ACCESS_NONE;
 
127
    break;
 
128
  case 1:
 
129
    m_ele->access = INK_ACCESS_MONITOR;
 
130
    break;
 
131
  case 2:
 
132
    m_ele->access = INK_ACCESS_MONITOR_VIEW;
 
133
    break;
 
134
  case 3:
 
135
    m_ele->access = INK_ACCESS_MONITOR_CHANGE;
 
136
    break;
 
137
  default:
 
138
    m_ele->access = INK_ACCESS_UNDEFINED;
 
139
    goto FORMAT_ERR;
 
140
  }
 
141
  m_ele->cfg_ele.error = INK_ERR_OKAY;
 
142
  return;
 
143
 
 
144
FORMAT_ERR:
 
145
  m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
146
  m_valid = false;
 
147
}
 
148
 
 
149
AdminAccessObj::~AdminAccessObj()
 
150
{
 
151
  INKAdminAccessEleDestroy(m_ele);
 
152
}
 
153
 
 
154
char *
 
155
AdminAccessObj::formatEleToRule()
 
156
{
 
157
  if (!isValid()) {
 
158
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
159
    return NULL;
 
160
  }
 
161
 
 
162
  short accessType;
 
163
 
 
164
  char buf[MAX_RULE_SIZE];
 
165
  memset(buf, 0, MAX_RULE_SIZE);
 
166
 
 
167
  switch (m_ele->access) {
 
168
  case INK_ACCESS_NONE:
 
169
    accessType = 0;
 
170
    break;
 
171
  case INK_ACCESS_MONITOR:
 
172
    accessType = 1;
 
173
    break;
 
174
  case INK_ACCESS_MONITOR_VIEW:
 
175
    accessType = 2;
 
176
    break;
 
177
  case INK_ACCESS_MONITOR_CHANGE:
 
178
    accessType = 3;
 
179
    break;
 
180
  default:
 
181
    accessType = 0;             // lv: just zero it
 
182
    // Handled here:
 
183
    // INK_ACCESS_UNDEFINED
 
184
    break;
 
185
  }
 
186
 
 
187
  snprintf(buf, sizeof(buf), "%s:%s:%d:", m_ele->user, m_ele->password, accessType);
 
188
 
 
189
  return xstrdup(buf);
 
190
}
 
191
 
 
192
bool AdminAccessObj::isValid()
 
193
{
 
194
  if (m_ele->cfg_ele.error != INK_ERR_OKAY) {
 
195
    m_valid = false;
 
196
  }
 
197
  // Must have a user
 
198
  if (!m_ele->user) {
 
199
    m_valid = false;
 
200
  }
 
201
  // Must have a password
 
202
  if (!m_ele->password) {
 
203
    m_valid = false;
 
204
  }
 
205
  // validate access type
 
206
  switch (m_ele->access) {
 
207
  case INK_ACCESS_NONE:
 
208
  case INK_ACCESS_MONITOR:
 
209
  case INK_ACCESS_MONITOR_VIEW:
 
210
  case INK_ACCESS_MONITOR_CHANGE:
 
211
    break;
 
212
  default:
 
213
    m_valid = false;
 
214
  }
 
215
 
 
216
  if (!m_valid) {
 
217
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
218
  }
 
219
 
 
220
  return m_valid;
 
221
}
 
222
 
 
223
INKCfgEle *
 
224
AdminAccessObj::getCfgEleCopy()
 
225
{
 
226
  return (INKCfgEle *) copy_admin_access_ele(m_ele);
 
227
}
 
228
 
 
229
//--------------------------------------------------------------------------
 
230
// CacheObj
 
231
//--------------------------------------------------------------------------
 
232
CacheObj::CacheObj(INKCacheEle * ele)
 
233
{
 
234
  m_ele = ele;
 
235
  m_valid = true;
 
236
  m_valid = isValid();
 
237
}
 
238
 
 
239
// assumes the specifiers are specified in specific order!!
 
240
CacheObj::CacheObj(TokenList * tokens)
 
241
{
 
242
  Token *tok;
 
243
  m_ele = INKCacheEleCreate(INK_TYPE_UNDEFINED);
 
244
  m_ele->cfg_ele.error = INK_ERR_OKAY;
 
245
  m_valid = true;
 
246
 
 
247
  if (!tokens) {
 
248
    goto FORMAT_ERR;
 
249
  }
 
250
 
 
251
  m_ele->cfg_ele.type = get_rule_type(tokens, INK_FNAME_CACHE_OBJ);
 
252
 
 
253
  // if any invalid values, set m_valid=false
 
254
  // convert token name and value into ele field
 
255
  tok = tokens->first();
 
256
  tok = tokens_to_pdss_format(tokens, tok, &(m_ele->cache_info));
 
257
 
 
258
  if (!tok) {                   // INVALID FORMAT
 
259
    goto FORMAT_ERR;
 
260
  }
 
261
 
 
262
  tok = tokens->next(tok);
 
263
  if (m_ele->cfg_ele.type == INK_CACHE_REVALIDATE ||
 
264
      m_ele->cfg_ele.type == INK_CACHE_PIN_IN_CACHE || m_ele->cfg_ele.type == INK_CACHE_TTL_IN_CACHE) {
 
265
    // must have a time specified
 
266
    if (strcmp(tok->name, "pin-in-cache") != 0 && strcmp(tok->name, "revalidate") != 0 &&
 
267
        strcmp(tok->name, "ttl-in-cache") != 0) {
 
268
      goto FORMAT_ERR;          // wrong token!!
 
269
    }
 
270
    if (string_to_hms_time(tok->value, &(m_ele->time_period)) != INK_ERR_OKAY) {
 
271
      goto FORMAT_ERR;
 
272
    }
 
273
  }
 
274
 
 
275
  return;
 
276
 
 
277
FORMAT_ERR:
 
278
  m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
279
  m_valid = false;
 
280
}
 
281
 
 
282
CacheObj::~CacheObj()
 
283
{
 
284
  INKCacheEleDestroy(m_ele);
 
285
}
 
286
 
 
287
char *
 
288
CacheObj::formatEleToRule()
 
289
{
 
290
  if (!isValid()) {
 
291
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
292
    return NULL;
 
293
  }
 
294
 
 
295
  char *pd_str, *time_str;
 
296
  char buf[MAX_RULE_SIZE];
 
297
  memset(buf, 0, MAX_RULE_SIZE);
 
298
 
 
299
  pd_str = pdest_sspec_to_string(m_ele->cache_info.pd_type, m_ele->cache_info.pd_val, &(m_ele->cache_info.sec_spec));
 
300
  if (!pd_str) {
 
301
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
302
    return NULL;
 
303
  }
 
304
  strncat(buf, pd_str, sizeof(buf) - strlen(buf) - 1);
 
305
  xfree(pd_str);
 
306
 
 
307
  switch (m_ele->cfg_ele.type) {
 
308
  case INK_CACHE_NEVER:
 
309
    strncat(buf, "action=never-cache ", sizeof(buf) - strlen(buf) - 1);
 
310
    break;
 
311
  case INK_CACHE_IGNORE_NO_CACHE:
 
312
    strncat(buf, "action=ignore-no-cache ", sizeof(buf) - strlen(buf) - 1);
 
313
    break;
 
314
  case INK_CACHE_IGNORE_CLIENT_NO_CACHE:
 
315
    strncat(buf, "action=ignore-client-no-cache ", sizeof(buf) - strlen(buf) - 1);
 
316
    break;
 
317
  case INK_CACHE_IGNORE_SERVER_NO_CACHE:
 
318
    strncat(buf, "action=ignore-server-no-cache ", sizeof(buf) - strlen(buf) - 1);
 
319
    break;
 
320
  case INK_CACHE_AUTH_CONTENT:
 
321
    strncat(buf, "action=cache-auth-content ", sizeof(buf) - strlen(buf) - 1);
 
322
    break;
 
323
  case INK_CACHE_PIN_IN_CACHE:
 
324
    strncat(buf, "pin-in-cache=", sizeof(buf) - strlen(buf) - 1);
 
325
    time_str = hms_time_to_string(m_ele->time_period);
 
326
    if (time_str) {
 
327
      strncat(buf, time_str, sizeof(buf) - strlen(buf) - 1);
 
328
      xfree(time_str);
 
329
    }
 
330
    strncat(buf, " ", sizeof(buf) - strlen(buf) - 1);
 
331
    break;
 
332
  case INK_CACHE_REVALIDATE:
 
333
    strncat(buf, "revalidate=", sizeof(buf) - strlen(buf) - 1);
 
334
    time_str = hms_time_to_string(m_ele->time_period);
 
335
    if (time_str) {
 
336
      strncat(buf, time_str, sizeof(buf) - strlen(buf) - 1);
 
337
      xfree(time_str);
 
338
    }
 
339
    strncat(buf, " ", sizeof(buf) - strlen(buf) - 1);
 
340
    break;
 
341
  case INK_CACHE_TTL_IN_CACHE:
 
342
    strncat(buf, "ttl-in-cache=", sizeof(buf) - strlen(buf) - 1);
 
343
    time_str = hms_time_to_string(m_ele->time_period);
 
344
    if (time_str) {
 
345
      strncat(buf, time_str, sizeof(buf) - strlen(buf) - 1);
 
346
      xfree(time_str);
 
347
    }
 
348
    strncat(buf, " ", sizeof(buf) - strlen(buf) - 1);
 
349
    break;
 
350
  default:
 
351
    // Handled here:
 
352
    // Lots of cases...
 
353
    break;
 
354
  }
 
355
 
 
356
  return xstrdup(buf);
 
357
}
 
358
 
 
359
bool CacheObj::isValid()
 
360
{
 
361
  char *
 
362
    timeStr;
 
363
 
 
364
  if (m_ele->cfg_ele.error != INK_ERR_OKAY) {
 
365
    m_valid = false;
 
366
  }
 
367
  // all Cache Ele's should have a prim dest, sec specs are optional
 
368
  if (!ccu_checkPdSspec(m_ele->cache_info)) {
 
369
    m_valid = false;
 
370
  }
 
371
  // only pin-in-cache, ttl, and revalidate rules have time period
 
372
  switch (m_ele->cfg_ele.type) {
 
373
  case INK_CACHE_NEVER:
 
374
  case INK_CACHE_IGNORE_NO_CACHE:
 
375
  case INK_CACHE_IGNORE_CLIENT_NO_CACHE:
 
376
  case INK_CACHE_IGNORE_SERVER_NO_CACHE:
 
377
  case INK_CACHE_AUTH_CONTENT:
 
378
    break;
 
379
  case INK_CACHE_PIN_IN_CACHE:
 
380
  case INK_CACHE_REVALIDATE:
 
381
  case INK_CACHE_TTL_IN_CACHE:
 
382
    timeStr = hms_time_to_string(m_ele->time_period);
 
383
    if (!timeStr) {
 
384
      m_valid = false;
 
385
    }
 
386
    if (timeStr)
 
387
      xfree(timeStr);
 
388
  default:
 
389
    // Handled here:
 
390
    // Lots of cases ...
 
391
    break;
 
392
  }
 
393
 
 
394
  if (!m_valid)
 
395
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
396
 
 
397
  return m_valid;
 
398
}
 
399
 
 
400
INKCfgEle *
 
401
CacheObj::getCfgEleCopy()
 
402
{
 
403
  return (INKCfgEle *) copy_cache_ele(m_ele);
 
404
}
 
405
 
 
406
 
 
407
//--------------------------------------------------------------------------
 
408
// CongestionObj
 
409
//--------------------------------------------------------------------------
 
410
CongestionObj::CongestionObj(INKCongestionEle * ele)
 
411
{
 
412
  m_ele = ele;
 
413
  m_valid = true;
 
414
  m_valid = isValid();
 
415
}
 
416
 
 
417
CongestionObj::CongestionObj(TokenList * tokens)
 
418
{
 
419
  Token *tok;
 
420
  m_ele = INKCongestionEleCreate();
 
421
  m_ele->cfg_ele.error = INK_ERR_OKAY;
 
422
  m_valid = true;
 
423
 
 
424
  if (!tokens) {
 
425
    goto FORMAT_ERR;
 
426
  }
 
427
 
 
428
  m_ele->cfg_ele.type = get_rule_type(tokens, INK_FNAME_CONGESTION);
 
429
 
 
430
  // if any invalid values, set m_valid=false
 
431
  // convert token name and value into ele field
 
432
  tok = tokens->first();
 
433
  //tok = tokens_to_pdss_format(tokens, tok, &(m_ele->congestion_info));
 
434
 
 
435
  if (!tok) {                   // INVALID FORMAT
 
436
    goto FORMAT_ERR;
 
437
  }
 
438
 
 
439
  if (strcmp(tok->name, "dest_domain") == 0) {
 
440
    m_ele->pd_type = INK_PD_DOMAIN;
 
441
  } else if (strcmp(tok->name, "dest_host") == 0) {
 
442
    m_ele->pd_type = INK_PD_HOST;
 
443
  } else if (strcmp(tok->name, "dest_ip") == 0) {
 
444
    m_ele->pd_type = INK_PD_IP;
 
445
  } else if (strcmp(tok->name, "host_regex") == 0) {
 
446
    m_ele->pd_type = INK_PD_URL_REGEX;
 
447
  }
 
448
  m_ele->pd_val = xstrdup(tok->value);
 
449
 
 
450
  // check for remaining tags
 
451
  tok = tokens->next(tok);
 
452
  while (tok) {
 
453
    if (!tok->name || !tok->value) {
 
454
      goto FORMAT_ERR;
 
455
    }
 
456
    if (strcmp(tok->name, "prefix") == 0) {
 
457
      m_ele->prefix = xstrdup(tok->value);
 
458
    } else if (strcmp(tok->name, "port") == 0) {
 
459
      m_ele->port = ink_atoi(tok->value);
 
460
    } else if (strcmp(tok->name, "congestion_scheme") == 0) {
 
461
      if (strcmp(tok->value, "per_ip") == 0) {
 
462
        m_ele->scheme = INK_HTTP_CONGEST_PER_IP;
 
463
      } else if (strcmp(tok->value, "per_host") == 0) {
 
464
        m_ele->scheme = INK_HTTP_CONGEST_PER_HOST;
 
465
      } else {
 
466
        goto FORMAT_ERR;
 
467
      }
 
468
    } else if (strcmp(tok->name, "max_connection_failures") == 0) {
 
469
      m_ele->max_connection_failures = ink_atoi(tok->value);
 
470
    } else if (strcmp(tok->name, "fail_window") == 0) {
 
471
      m_ele->fail_window = ink_atoi(tok->value);
 
472
    } else if (strcmp(tok->name, "proxy_retry_interval") == 0) {
 
473
      m_ele->proxy_retry_interval = ink_atoi(tok->value);
 
474
    } else if (strcmp(tok->name, "client_wait_interval") == 0) {
 
475
      m_ele->client_wait_interval = ink_atoi(tok->value);
 
476
    } else if (strcmp(tok->name, "wait_interval_alpha") == 0) {
 
477
      m_ele->wait_interval_alpha = ink_atoi(tok->value);
 
478
    } else if (strcmp(tok->name, "live_os_conn_timeout") == 0) {
 
479
      m_ele->live_os_conn_timeout = ink_atoi(tok->value);
 
480
    } else if (strcmp(tok->name, "live_os_conn_retries") == 0) {
 
481
      m_ele->live_os_conn_retries = ink_atoi(tok->value);
 
482
    } else if (strcmp(tok->name, "dead_os_conn_timeout") == 0) {
 
483
      m_ele->dead_os_conn_timeout = ink_atoi(tok->value);
 
484
    } else if (strcmp(tok->name, "dead_os_conn_retries") == 0) {
 
485
      m_ele->dead_os_conn_retries = ink_atoi(tok->value);
 
486
    } else if (strcmp(tok->name, "max_connection") == 0) {
 
487
      m_ele->max_connection = ink_atoi(tok->value);
 
488
    } else if (strcmp(tok->name, "error_page_uri") == 0) {
 
489
      m_ele->error_page_uri = xstrdup(tok->value);
 
490
    } else {
 
491
      goto FORMAT_ERR;
 
492
    }
 
493
    tok = tokens->next(tok);
 
494
  }
 
495
  return;
 
496
 
 
497
FORMAT_ERR:
 
498
  m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
499
  m_valid = false;
 
500
}
 
501
 
 
502
CongestionObj::~CongestionObj()
 
503
{
 
504
  INKCongestionEleDestroy(m_ele);
 
505
}
 
506
 
 
507
//
 
508
// will always print defaults in the rule
 
509
//
 
510
char *
 
511
CongestionObj::formatEleToRule()
 
512
{
 
513
  if (!isValid()) {
 
514
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
515
    return NULL;
 
516
  }
 
517
 
 
518
  char buf[MAX_BUF_SIZE];
 
519
  size_t pos = 0;
 
520
  int psize;
 
521
  memset(buf, 0, MAX_BUF_SIZE);
 
522
 
 
523
  // push in primary destination
 
524
  if (pos < sizeof(buf)) {
 
525
    switch (m_ele->pd_type) {
 
526
    case INK_PD_DOMAIN:
 
527
      psize = snprintf(buf + pos, sizeof(buf) - pos, "dest_domain=%s ", m_ele->pd_val);
 
528
      break;
 
529
    case INK_PD_HOST:
 
530
      psize = snprintf(buf + pos, sizeof(buf) - pos, "dest_host=%s ", m_ele->pd_val);
 
531
      break;
 
532
    case INK_PD_IP:
 
533
      psize = snprintf(buf + pos, sizeof(buf) - pos, "dest_ip=%s ", m_ele->pd_val);
 
534
      break;
 
535
    case INK_PD_URL_REGEX:
 
536
      psize = snprintf(buf + pos, sizeof(buf) - pos, "host_regex=%s ", m_ele->pd_val);
 
537
      break;
 
538
    default:
 
539
      psize = 0;
 
540
      // Handled here:
 
541
      // INK_PD_UNDEFINED
 
542
      break;
 
543
    }
 
544
    if (psize > 0)
 
545
      pos += psize;
 
546
  }
 
547
  // secondary specifiers
 
548
  if (m_ele->prefix) {
 
549
    if (pos < sizeof(buf) && (psize = snprintf(buf + pos, sizeof(buf) - pos, "prefix=%s ", m_ele->prefix)) > 0)
 
550
      pos += psize;
 
551
  }
 
552
  if (m_ele->port > 0) {
 
553
    if (pos < sizeof(buf) && (psize = snprintf(buf + pos, sizeof(buf) - pos, "port=%d ", m_ele->port)) > 0)
 
554
      pos += psize;
 
555
  }
 
556
 
 
557
 
 
558
  if (pos < sizeof(buf) &&
 
559
      (psize =
 
560
       snprintf(buf + pos, sizeof(buf) - pos, "max_connection_failures=%d ", m_ele->max_connection_failures)) > 0)
 
561
    pos += psize;
 
562
  if (pos < sizeof(buf) &&
 
563
      (psize = snprintf(buf + pos, sizeof(buf) - pos, "fail_window=%d ", m_ele->fail_window)) > 0)
 
564
    pos += psize;
 
565
  if (pos < sizeof(buf) &&
 
566
      (psize = snprintf(buf + pos, sizeof(buf) - pos, "proxy_retry_interval=%d ", m_ele->proxy_retry_interval)) > 0)
 
567
    pos += psize;
 
568
  if (pos < sizeof(buf) &&
 
569
      (psize = snprintf(buf + pos, sizeof(buf) - pos, "client_wait_interval=%d ", m_ele->client_wait_interval)) > 0)
 
570
    pos += psize;
 
571
  if (pos < sizeof(buf) &&
 
572
      (psize = snprintf(buf + pos, sizeof(buf) - pos, "wait_interval_alpha=%d ", m_ele->wait_interval_alpha)) > 0)
 
573
    pos += psize;
 
574
  if (pos < sizeof(buf) &&
 
575
      (psize = snprintf(buf + pos, sizeof(buf) - pos, "live_os_conn_timeout=%d ", m_ele->live_os_conn_timeout)) > 0)
 
576
    pos += psize;
 
577
  if (pos < sizeof(buf) &&
 
578
      (psize = snprintf(buf + pos, sizeof(buf) - pos, "live_os_conn_retries=%d ", m_ele->live_os_conn_retries)) > 0)
 
579
    pos += psize;
 
580
  if (pos < sizeof(buf) &&
 
581
      (psize = snprintf(buf + pos, sizeof(buf) - pos, "dead_os_conn_timeout=%d ", m_ele->dead_os_conn_timeout)) > 0)
 
582
    pos += psize;
 
583
  if (pos < sizeof(buf) &&
 
584
      (psize = snprintf(buf + pos, sizeof(buf) - pos, "dead_os_conn_retries=%d ", m_ele->dead_os_conn_retries)) > 0)
 
585
    pos += psize;
 
586
  if (pos < sizeof(buf) &&
 
587
      (psize = snprintf(buf + pos, sizeof(buf) - pos, "max_connection=%d ", m_ele->max_connection)) > 0)
 
588
    pos += psize;
 
589
  if (m_ele->error_page_uri) {
 
590
    if (pos < sizeof(buf) &&
 
591
        (psize = snprintf(buf + pos, sizeof(buf) - pos, "error_page=%s ", m_ele->error_page_uri)) > 0)
 
592
      pos += psize;
 
593
  }
 
594
  switch (m_ele->scheme) {
 
595
  case INK_HTTP_CONGEST_PER_IP:
 
596
    if (pos<sizeof(buf) && (psize = snprintf(buf + pos, sizeof(buf) - pos, "congestion_scheme=per_ip "))> 0)
 
597
      pos += psize;
 
598
    break;
 
599
  case INK_HTTP_CONGEST_PER_HOST:
 
600
    if (pos<sizeof(buf) && (psize = snprintf(buf + pos, sizeof(buf) - pos, "congestion_scheme=per_host "))> 0)
 
601
      pos += psize;
 
602
    break;
 
603
  default:
 
604
    ;
 
605
  }
 
606
 
 
607
  return xstrdup(buf);
 
608
}
 
609
 
 
610
bool CongestionObj::isValid()
 
611
{
 
612
  if (m_ele->cfg_ele.error != INK_ERR_OKAY) {
 
613
    m_valid = false;
 
614
  }
 
615
  // all Congestion Ele's should have a prim dest, sec specs are optional
 
616
  if (!m_ele->pd_val)
 
617
    m_valid = false;
 
618
 
 
619
  if (!m_valid)
 
620
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
621
  return m_valid;
 
622
}
 
623
 
 
624
INKCfgEle *
 
625
CongestionObj::getCfgEleCopy()
 
626
{
 
627
  return (INKCfgEle *) copy_congestion_ele(m_ele);
 
628
}
 
629
 
 
630
 
 
631
//--------------------------------------------------------------------------
 
632
// HostingObj
 
633
//--------------------------------------------------------------------------
 
634
HostingObj::HostingObj(INKHostingEle * ele)
 
635
{
 
636
  m_ele = ele;
 
637
  m_valid = true;
 
638
  m_valid = isValid();
 
639
}
 
640
 
 
641
HostingObj::HostingObj(TokenList * tokens)
 
642
{
 
643
  Token *token;
 
644
 
 
645
  m_ele = INKHostingEleCreate();
 
646
  m_ele->cfg_ele.error = INK_ERR_OKAY;
 
647
  m_valid = true;
 
648
 
 
649
  if (!tokens || tokens->length != 2) {
 
650
    goto FORMAT_ERR;
 
651
  }
 
652
 
 
653
  m_ele->cfg_ele.type = get_rule_type(tokens, INK_FNAME_HOSTING);
 
654
  if (m_ele->cfg_ele.type == INK_TYPE_UNDEFINED) {
 
655
    goto FORMAT_ERR;
 
656
  }
 
657
  // First Token
 
658
  token = tokens->first();
 
659
  if (!token->value) {
 
660
    goto FORMAT_ERR;
 
661
  }
 
662
  if (strcmp(token->name, "hostname") == 0) {
 
663
    m_ele->pd_type = INK_PD_HOST;
 
664
  } else if (strcmp(token->name, "domain") == 0) {
 
665
    m_ele->pd_type = INK_PD_DOMAIN;
 
666
  } else {
 
667
    goto FORMAT_ERR;
 
668
  }
 
669
  m_ele->pd_val = xstrdup(token->value);
 
670
 
 
671
  // Second Token
 
672
  token = tokens->next(token);
 
673
  if (!token->value) {
 
674
    goto FORMAT_ERR;
 
675
  }
 
676
  if (strcmp(token->name, "partition") != 0) {
 
677
    goto FORMAT_ERR;
 
678
  }
 
679
  m_ele->partitions = string_to_int_list(token->value, LIST_DELIMITER);
 
680
  return;
 
681
 
 
682
FORMAT_ERR:
 
683
  m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
684
  m_valid = false;
 
685
 
 
686
}
 
687
 
 
688
HostingObj::~HostingObj()
 
689
{
 
690
  INKHostingEleDestroy(m_ele);
 
691
}
 
692
 
 
693
char *
 
694
HostingObj::formatEleToRule()
 
695
{
 
696
  if (!isValid()) {
 
697
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
698
    return NULL;
 
699
  }
 
700
 
 
701
  char *list_str;
 
702
  char buf[MAX_RULE_SIZE];
 
703
  memset(buf, 0, MAX_RULE_SIZE);
 
704
 
 
705
  switch (m_ele->pd_type) {
 
706
  case INK_PD_HOST:
 
707
    strncat(buf, "hostname=", sizeof(buf) - strlen(buf) - 1);
 
708
    break;
 
709
  case INK_PD_DOMAIN:
 
710
    strncat(buf, "domain=", sizeof(buf) - strlen(buf) - 1);
 
711
    break;
 
712
  default:
 
713
    // Handled here:
 
714
    // Lots of cases...
 
715
    break;
 
716
  }
 
717
 
 
718
  list_str = int_list_to_string(m_ele->partitions, ",");
 
719
  strncat(buf, m_ele->pd_val, sizeof(buf) - strlen(buf) - 1);
 
720
  strncat(buf, " partition=", sizeof(buf) - strlen(buf) - 1);
 
721
  strncat(buf, list_str, sizeof(buf) - strlen(buf) - 1);
 
722
  xfree(list_str);
 
723
 
 
724
  return xstrdup(buf);
 
725
}
 
726
 
 
727
bool HostingObj::isValid()
 
728
{
 
729
  int *
 
730
    part;
 
731
  int
 
732
    len,
 
733
    i;
 
734
 
 
735
  if (m_ele->pd_type == INK_PD_UNDEFINED) {
 
736
    m_valid = false;
 
737
    goto Lend;
 
738
  }
 
739
 
 
740
  if (!m_ele->pd_val) {
 
741
    m_valid = false;
 
742
    goto Lend;
 
743
  }
 
744
 
 
745
  if (!m_ele->partitions || !INKIntListIsValid(m_ele->partitions, 0, 50000)) {
 
746
    m_valid = false;
 
747
    goto Lend;
 
748
  }
 
749
  // check that each partition is between 1-255
 
750
  len = INKIntListLen(m_ele->partitions);
 
751
  for (i = 0; i < len; i++) {
 
752
    part = INKIntListDequeue(m_ele->partitions);
 
753
    if (*part<1 || *part> 255) {
 
754
      INKIntListEnqueue(m_ele->partitions, part);
 
755
      m_valid = false;
 
756
      goto Lend;
 
757
    }
 
758
    INKIntListEnqueue(m_ele->partitions, part);
 
759
  }
 
760
 
 
761
Lend:
 
762
  if (!m_valid) {
 
763
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
764
  }
 
765
  return m_valid;
 
766
}
 
767
 
 
768
INKCfgEle *
 
769
HostingObj::getCfgEleCopy()
 
770
{
 
771
  return (INKCfgEle *) copy_hosting_ele(m_ele);
 
772
}
 
773
 
 
774
//--------------------------------------------------------------------------
 
775
// IcpObj
 
776
//--------------------------------------------------------------------------
 
777
IcpObj::IcpObj(INKIcpEle * ele)
 
778
{
 
779
  m_ele = ele;
 
780
  m_valid = true;
 
781
  m_valid = isValid();
 
782
}
 
783
 
 
784
IcpObj::IcpObj(TokenList * tokens)
 
785
{
 
786
  Token *token;
 
787
  int i;
 
788
 
 
789
  m_ele = INKIcpEleCreate();
 
790
  m_ele->cfg_ele.error = INK_ERR_OKAY;
 
791
  m_valid = true;
 
792
 
 
793
  if (!tokens || tokens->length < 8) {
 
794
    goto FORMAT_ERR;
 
795
  }
 
796
 
 
797
  m_ele->cfg_ele.type = get_rule_type(tokens, INK_FNAME_ICP_PEER);
 
798
  if (m_ele->cfg_ele.type == INK_TYPE_UNDEFINED) {
 
799
    goto FORMAT_ERR;
 
800
  }
 
801
 
 
802
  token = tokens->first();
 
803
 
 
804
  for (i = 0; i < 8; i++) {
 
805
    if (!token->name || token->value) {
 
806
      goto FORMAT_ERR;
 
807
    }
 
808
    char *alias = token->name;
 
809
 
 
810
    unsigned short cache_type;
 
811
    int mc_ttl;
 
812
    int is_multicast;
 
813
 
 
814
    switch (i) {
 
815
    case 0:
 
816
      if (strlen(alias) > 0)
 
817
        m_ele->peer_hostname = xstrdup(alias);
 
818
      break;
 
819
    case 1:
 
820
      if (strlen(alias) > 0) {
 
821
        m_ele->peer_host_ip_addr = string_to_ip_addr(alias);
 
822
        if (!m_ele->peer_host_ip_addr)
 
823
          goto FORMAT_ERR;
 
824
      }
 
825
      break;
 
826
    case 2:
 
827
      cache_type = ink_atoi(alias);     // what if failed?
 
828
      switch (cache_type) {
 
829
      case 1:
 
830
        m_ele->peer_type = INK_ICP_PARENT;
 
831
        break;
 
832
      case 2:
 
833
        m_ele->peer_type = INK_ICP_SIBLING;
 
834
        break;
 
835
      default:
 
836
        m_ele->peer_type = INK_ICP_UNDEFINED;
 
837
      }
 
838
      break;
 
839
    case 3:
 
840
      m_ele->peer_proxy_port = ink_atoi(alias);
 
841
      break;
 
842
    case 4:
 
843
      m_ele->peer_icp_port = ink_atoi(alias);
 
844
      break;
 
845
    case 5:
 
846
      is_multicast = ink_atoi(alias);
 
847
      switch (is_multicast) {
 
848
      case 0:
 
849
        m_ele->is_multicast = false;
 
850
        break;
 
851
      case 1:
 
852
        m_ele->is_multicast = true;
 
853
        break;
 
854
      default:
 
855
        // ERROR:MC_on can only be either 0 or 1
 
856
        goto FORMAT_ERR;
 
857
      }
 
858
      break;
 
859
    case 6:
 
860
      m_ele->mc_ip_addr = string_to_ip_addr(alias);
 
861
      if (!m_ele->mc_ip_addr)
 
862
        goto FORMAT_ERR;
 
863
      break;
 
864
    case 7:
 
865
      mc_ttl = ink_atoi(alias);
 
866
      switch (mc_ttl) {
 
867
      case 1:
 
868
        m_ele->mc_ttl = INK_MC_TTL_SINGLE_SUBNET;
 
869
        break;
 
870
      case 2:
 
871
        m_ele->mc_ttl = INK_MC_TTL_MULT_SUBNET;
 
872
        break;
 
873
      default:
 
874
        m_ele->mc_ttl = INK_MC_TTL_UNDEFINED;
 
875
      }
 
876
      break;
 
877
    default:
 
878
      goto FORMAT_ERR;
 
879
    }
 
880
    token = tokens->next(token);
 
881
  }
 
882
 
 
883
  return;
 
884
 
 
885
FORMAT_ERR:
 
886
  m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
887
  m_valid = false;
 
888
}
 
889
 
 
890
IcpObj::~IcpObj()
 
891
{
 
892
  INKIcpEleDestroy(m_ele);
 
893
}
 
894
 
 
895
char *
 
896
IcpObj::formatEleToRule()
 
897
{
 
898
  char *ip_str1, *ip_str2;
 
899
  char buf[MAX_RULE_SIZE];
 
900
  int peer_type = 0;
 
901
 
 
902
  if (!isValid()) {
 
903
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
904
    return NULL;
 
905
  }
 
906
 
 
907
  memset(buf, 0, MAX_RULE_SIZE);
 
908
 
 
909
  switch (m_ele->peer_type) {
 
910
  case INK_ICP_PARENT:
 
911
    peer_type = 1;
 
912
    break;
 
913
  case INK_ICP_SIBLING:
 
914
    peer_type = 2;
 
915
    break;
 
916
  default:
 
917
    // Handled here:
 
918
    // INK_ICP_UNDEFINED
 
919
    break;
 
920
  }
 
921
 
 
922
  // optional field
 
923
  if (m_ele->peer_host_ip_addr)
 
924
    ip_str1 = ip_addr_to_string(m_ele->peer_host_ip_addr);
 
925
  else
 
926
    ip_str1 = xstrdup("");
 
927
 
 
928
  // optional field
 
929
  if (m_ele->mc_ip_addr)
 
930
    ip_str2 = ip_addr_to_string(m_ele->mc_ip_addr);
 
931
  else
 
932
    ip_str2 = xstrdup("0.0.0.0");
 
933
 
 
934
  if (m_ele->peer_hostname) {
 
935
    snprintf(buf, sizeof(buf), "%s:%s:%d:%d:%d:%d:%s:",
 
936
             m_ele->peer_hostname,
 
937
             ip_str1, peer_type, m_ele->peer_proxy_port, m_ele->peer_icp_port, (m_ele->is_multicast ? 1 : 0), ip_str2);
 
938
  } else {
 
939
    snprintf(buf, sizeof(buf), ":%s:%d:%d:%d:%d:%s:",
 
940
             ip_str1, peer_type, m_ele->peer_proxy_port, m_ele->peer_icp_port, (m_ele->is_multicast ? 1 : 0), ip_str2);
 
941
  }
 
942
 
 
943
  switch (m_ele->mc_ttl) {
 
944
  case INK_MC_TTL_SINGLE_SUBNET:
 
945
    strncat(buf, "1:", sizeof(buf) - strlen(buf) - 1);
 
946
    break;
 
947
  case INK_MC_TTL_MULT_SUBNET:
 
948
    strncat(buf, "2:", sizeof(buf) - strlen(buf) - 1);
 
949
    break;
 
950
  case INK_MC_TTL_UNDEFINED:
 
951
    strncat(buf, "0:", sizeof(buf) - strlen(buf) - 1);
 
952
    break;
 
953
  }
 
954
 
 
955
  if (ip_str1)
 
956
    xfree(ip_str1);
 
957
  if (ip_str2)
 
958
    xfree(ip_str2);
 
959
  return xstrdup(buf);
 
960
}
 
961
 
 
962
bool IcpObj::isValid()
 
963
{
 
964
  if (m_ele->cfg_ele.error != INK_ERR_OKAY) {
 
965
    m_valid = false;
 
966
  }
 
967
  // either hostname or IP must be specified
 
968
  if (!m_ele->peer_hostname && !m_ele->peer_host_ip_addr) {
 
969
    m_valid = false;
 
970
  }
 
971
  // check valid host IP
 
972
  if (m_ele->peer_host_ip_addr && !ccu_checkIpAddr(m_ele->peer_host_ip_addr)) {
 
973
    m_valid = false;
 
974
  }
 
975
  // check valid cache type
 
976
  if (m_ele->peer_type == INK_ICP_UNDEFINED) {
 
977
    m_valid = false;
 
978
  }
 
979
  // check valid ports
 
980
  if (!ccu_checkPortNum(m_ele->peer_proxy_port)) {
 
981
    m_valid = false;
 
982
  }
 
983
 
 
984
  if (!ccu_checkPortNum(m_ele->peer_icp_port)) {
 
985
    m_valid = false;
 
986
  }
 
987
  // check valid multicast values: mc_ttl, mc_ip, if enabled
 
988
  if (m_ele->is_multicast) {
 
989
    // a valid multicast address must be between 224.0.0.0-239.255.255.255
 
990
    if (!ccu_checkIpAddr(m_ele->mc_ip_addr, "224.0.0.0", "239.255.255.255") || m_ele->mc_ttl == INK_MC_TTL_UNDEFINED)
 
991
      m_valid = false;
 
992
  } else {                      // multicast disabled; only valid mc ip is "0.0.0.0"
 
993
    if (m_ele->mc_ip_addr && strcmp(m_ele->mc_ip_addr, "0.0.0.0") != 0)
 
994
      m_valid = false;
 
995
  }
 
996
 
 
997
  if (!m_valid) {
 
998
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
999
  }
 
1000
 
 
1001
  return m_valid;
 
1002
}
 
1003
 
 
1004
INKCfgEle *
 
1005
IcpObj::getCfgEleCopy()
 
1006
{
 
1007
  return (INKCfgEle *) copy_icp_ele(m_ele);
 
1008
}
 
1009
 
 
1010
//--------------------------------------------------------------------------
 
1011
// IpAllowObj
 
1012
//--------------------------------------------------------------------------
 
1013
IpAllowObj::IpAllowObj(INKIpAllowEle * ele)
 
1014
{
 
1015
  m_ele = ele;
 
1016
  m_valid = true;
 
1017
  m_valid = isValid();
 
1018
}
 
1019
 
 
1020
IpAllowObj::IpAllowObj(TokenList * tokens)
 
1021
{
 
1022
  Token *token;
 
1023
 
 
1024
  m_ele = INKIpAllowEleCreate();
 
1025
  m_ele->cfg_ele.error = INK_ERR_OKAY;
 
1026
  m_valid = true;
 
1027
 
 
1028
  if (!tokens || (tokens->length != 2)) {
 
1029
    goto FORMAT_ERR;
 
1030
  }
 
1031
 
 
1032
  m_ele->cfg_ele.type = get_rule_type(tokens, INK_FNAME_IP_ALLOW);
 
1033
  if (m_ele->cfg_ele.type == INK_TYPE_UNDEFINED) {
 
1034
    goto FORMAT_ERR;
 
1035
  }
 
1036
 
 
1037
  token = tokens->first();
 
1038
  if (!token->name || strcmp(token->name, "src_ip")) {
 
1039
    goto FORMAT_ERR;
 
1040
  }
 
1041
  if (!token->value) {
 
1042
    goto FORMAT_ERR;
 
1043
  } else {
 
1044
    m_ele->src_ip_addr = string_to_ip_addr_ele(token->value);
 
1045
  }
 
1046
 
 
1047
  token = tokens->next(token);
 
1048
  if (!token->name || strcmp(token->name, "action")) {
 
1049
    goto FORMAT_ERR;
 
1050
  }
 
1051
  if (!token->value) {
 
1052
    goto FORMAT_ERR;
 
1053
  } else {
 
1054
    if (!strcmp(token->value, "ip_allow")) {
 
1055
      m_ele->action = INK_IP_ALLOW_ALLOW;
 
1056
    } else if (strcmp(token->value, "ip_deny") == 0) {
 
1057
      m_ele->action = INK_IP_ALLOW_DENY;
 
1058
    } else {
 
1059
      m_ele->action = INK_IP_ALLOW_UNDEFINED;
 
1060
    }
 
1061
  }
 
1062
  return;
 
1063
 
 
1064
FORMAT_ERR:
 
1065
  m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
1066
  m_valid = false;
 
1067
}
 
1068
 
 
1069
IpAllowObj::~IpAllowObj()
 
1070
{
 
1071
  INKIpAllowEleDestroy(m_ele);
 
1072
}
 
1073
 
 
1074
char *
 
1075
IpAllowObj::formatEleToRule()
 
1076
{
 
1077
  if (!isValid()) {
 
1078
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
1079
    return NULL;;
 
1080
  }
 
1081
 
 
1082
  char *rule;
 
1083
  char buf[MAX_RULE_SIZE];
 
1084
  memset(buf, 0, MAX_RULE_SIZE);
 
1085
 
 
1086
  ink_strncpy(buf, "src_ip=", sizeof(buf));
 
1087
  if (m_ele->src_ip_addr) {
 
1088
    char *ip_str = ip_addr_ele_to_string(m_ele->src_ip_addr);
 
1089
    if (ip_str) {
 
1090
      strncat(buf, ip_str, sizeof(buf) - strlen(buf) - 1);
 
1091
      xfree(ip_str);
 
1092
    }
 
1093
  }
 
1094
 
 
1095
  strncat(buf, " action=", sizeof(buf) - strlen(buf) - 1);
 
1096
  switch (m_ele->action) {
 
1097
  case INK_IP_ALLOW_ALLOW:
 
1098
    strncat(buf, "ip_allow", sizeof(buf) - strlen(buf) - 1);
 
1099
    break;
 
1100
  case INK_IP_ALLOW_DENY:
 
1101
    strncat(buf, "ip_deny", sizeof(buf) - strlen(buf) - 1);
 
1102
    break;
 
1103
  default:
 
1104
    // Handled here:
 
1105
    // INK_IP_ALLOW_UNDEFINED
 
1106
    break;
 
1107
  }
 
1108
 
 
1109
  rule = xstrdup(buf);
 
1110
  return rule;
 
1111
}
 
1112
 
 
1113
bool IpAllowObj::isValid()
 
1114
{
 
1115
  if (m_ele->cfg_ele.error != INK_ERR_OKAY) {
 
1116
    m_valid = false;
 
1117
  }
 
1118
 
 
1119
  if (!m_ele->src_ip_addr) {
 
1120
    m_valid = false;
 
1121
  }
 
1122
 
 
1123
  switch (m_ele->action) {
 
1124
  case INK_IP_ALLOW_ALLOW:
 
1125
  case INK_IP_ALLOW_DENY:
 
1126
    break;
 
1127
  default:
 
1128
    m_valid = false;
 
1129
  }
 
1130
 
 
1131
  if (!m_valid) {
 
1132
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
1133
  }
 
1134
  return m_valid;
 
1135
}
 
1136
 
 
1137
INKCfgEle *
 
1138
IpAllowObj::getCfgEleCopy()
 
1139
{
 
1140
  return (INKCfgEle *) copy_ip_allow_ele(m_ele);
 
1141
}
 
1142
 
 
1143
//--------------------------------------------------------------------------
 
1144
// MgmtAllowObj
 
1145
//--------------------------------------------------------------------------
 
1146
MgmtAllowObj::MgmtAllowObj(INKMgmtAllowEle * ele)
 
1147
{
 
1148
  m_ele = ele;
 
1149
  m_valid = true;
 
1150
  m_valid = isValid();
 
1151
}
 
1152
 
 
1153
MgmtAllowObj::MgmtAllowObj(TokenList * tokens)
 
1154
{
 
1155
  Token *token;
 
1156
 
 
1157
  m_ele = INKMgmtAllowEleCreate();
 
1158
  m_ele->cfg_ele.error = INK_ERR_OKAY;
 
1159
  m_valid = true;
 
1160
 
 
1161
  if (!tokens || (tokens->length != 2)) {
 
1162
    goto FORMAT_ERR;
 
1163
  }
 
1164
 
 
1165
  m_ele->cfg_ele.type = get_rule_type(tokens, INK_FNAME_IP_ALLOW);
 
1166
  if (m_ele->cfg_ele.type == INK_TYPE_UNDEFINED) {
 
1167
    goto FORMAT_ERR;
 
1168
  }
 
1169
 
 
1170
  token = tokens->first();
 
1171
  if (!token->name || strcmp(token->name, "src_ip")) {
 
1172
    goto FORMAT_ERR;
 
1173
  }
 
1174
  if (!token->value) {
 
1175
    goto FORMAT_ERR;
 
1176
  } else {
 
1177
    m_ele->src_ip_addr = string_to_ip_addr_ele(token->value);
 
1178
  }
 
1179
 
 
1180
  token = tokens->next(token);
 
1181
  if (!token->name || strcmp(token->name, "action")) {
 
1182
    goto FORMAT_ERR;
 
1183
  }
 
1184
  if (!token->value) {
 
1185
    goto FORMAT_ERR;
 
1186
  } else {
 
1187
    if (!strcmp(token->value, "ip_allow")) {
 
1188
      m_ele->action = INK_MGMT_ALLOW_ALLOW;
 
1189
    } else if (strcmp(token->value, "ip_deny") == 0) {
 
1190
      m_ele->action = INK_MGMT_ALLOW_DENY;
 
1191
    } else {
 
1192
      m_ele->action = INK_MGMT_ALLOW_UNDEFINED;
 
1193
    }
 
1194
  }
 
1195
  return;
 
1196
 
 
1197
FORMAT_ERR:
 
1198
  m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
1199
  m_valid = false;
 
1200
}
 
1201
 
 
1202
MgmtAllowObj::~MgmtAllowObj()
 
1203
{
 
1204
  INKMgmtAllowEleDestroy(m_ele);
 
1205
}
 
1206
 
 
1207
char *
 
1208
MgmtAllowObj::formatEleToRule()
 
1209
{
 
1210
  if (!isValid()) {
 
1211
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
1212
    return NULL;
 
1213
  }
 
1214
 
 
1215
  char *rule;
 
1216
  char buf[MAX_RULE_SIZE];
 
1217
  memset(buf, 0, MAX_RULE_SIZE);
 
1218
 
 
1219
  ink_strncpy(buf, "src_ip=", sizeof(buf));
 
1220
  if (m_ele->src_ip_addr) {
 
1221
    char *ip_str = ip_addr_ele_to_string(m_ele->src_ip_addr);
 
1222
    if (ip_str) {
 
1223
      strncat(buf, ip_str, sizeof(buf) - strlen(buf) - 1);
 
1224
      xfree(ip_str);
 
1225
    } else {
 
1226
      return NULL;
 
1227
    }
 
1228
  }
 
1229
 
 
1230
  strncat(buf, " action=", sizeof(buf) - strlen(buf) - 1);
 
1231
  switch (m_ele->action) {
 
1232
  case INK_MGMT_ALLOW_ALLOW:
 
1233
    strncat(buf, "ip_allow", sizeof(buf) - strlen(buf) - 1);
 
1234
    break;
 
1235
  case INK_MGMT_ALLOW_DENY:
 
1236
    strncat(buf, "ip_deny", sizeof(buf) - strlen(buf) - 1);
 
1237
    break;
 
1238
  default:
 
1239
    // Handled here:
 
1240
    // INK_MGMT_ALLOW_UNDEFINED
 
1241
    break;
 
1242
  }
 
1243
 
 
1244
  rule = xstrdup(buf);
 
1245
 
 
1246
  return rule;
 
1247
}
 
1248
 
 
1249
bool MgmtAllowObj::isValid()
 
1250
{
 
1251
  if (m_ele->cfg_ele.error != INK_ERR_OKAY) {
 
1252
    m_valid = false;
 
1253
  }
 
1254
  // must specify source IP addr
 
1255
  if (!m_ele->src_ip_addr) {
 
1256
    m_valid = false;
 
1257
  }
 
1258
 
 
1259
  switch (m_ele->action) {
 
1260
  case INK_MGMT_ALLOW_ALLOW:
 
1261
  case INK_MGMT_ALLOW_DENY:
 
1262
    break;
 
1263
  default:
 
1264
    m_valid = false;
 
1265
  }
 
1266
 
 
1267
  if (!m_valid) {
 
1268
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
1269
  }
 
1270
  return m_valid;
 
1271
}
 
1272
 
 
1273
INKCfgEle *
 
1274
MgmtAllowObj::getCfgEleCopy()
 
1275
{
 
1276
  return (INKCfgEle *) copy_mgmt_allow_ele(m_ele);
 
1277
}
 
1278
 
 
1279
 
 
1280
//--------------------------------------------------------------------------
 
1281
// ParentProxyObj
 
1282
//--------------------------------------------------------------------------
 
1283
ParentProxyObj::ParentProxyObj(INKParentProxyEle * ele)
 
1284
{
 
1285
  m_ele = ele;
 
1286
  m_valid = true;
 
1287
  m_valid = isValid();
 
1288
}
 
1289
 
 
1290
ParentProxyObj::ParentProxyObj(TokenList * tokens)
 
1291
{
 
1292
  Token *tok;
 
1293
  m_ele = INKParentProxyEleCreate(INK_TYPE_UNDEFINED);
 
1294
  m_ele->cfg_ele.error = INK_ERR_OKAY;
 
1295
  m_valid = true;
 
1296
 
 
1297
  if (!tokens || tokens->length < 1) {
 
1298
    goto FORMAT_ERR;
 
1299
  }
 
1300
 
 
1301
  m_ele->cfg_ele.type = get_rule_type(tokens, INK_FNAME_PARENT_PROXY);
 
1302
  if (m_ele->cfg_ele.type == INK_TYPE_UNDEFINED) {
 
1303
    goto FORMAT_ERR;
 
1304
  }
 
1305
 
 
1306
  tok = tokens->first();
 
1307
  tok = tokens_to_pdss_format(tokens, tok, &(m_ele->parent_info));
 
1308
  if (tok == NULL) {
 
1309
    goto FORMAT_ERR;
 
1310
  }
 
1311
  // search parent and round_robin action tags
 
1312
  for (tok = tokens->next(tok); tok; tok = tokens->next(tok)) {
 
1313
    if (strcmp(tok->name, "round_robin") == 0) {
 
1314
      // sanity check
 
1315
      if (!tok->value) {
 
1316
        goto FORMAT_ERR;
 
1317
      }
 
1318
      if (strcmp(tok->value, "true") == 0) {
 
1319
        m_ele->rr = INK_RR_TRUE;
 
1320
      } else if (strcmp(tok->value, "strict") == 0) {
 
1321
        m_ele->rr = INK_RR_STRICT;
 
1322
      } else if (strcmp(tok->value, "false") == 0) {
 
1323
        m_ele->rr = INK_RR_FALSE;
 
1324
      } else {
 
1325
        m_ele->rr = INK_RR_NONE;
 
1326
        goto FORMAT_ERR;
 
1327
      }
 
1328
 
 
1329
    } else if (strcmp(tok->name, "parent") == 0) {
 
1330
      // sanity check
 
1331
      if (!tok->value) {
 
1332
        goto FORMAT_ERR;
 
1333
      }
 
1334
      m_ele->proxy_list = string_to_domain_list(tok->value, ";");
 
1335
 
 
1336
    } else if (strcmp(tok->name, "go_direct") == 0) {
 
1337
      // sanity check
 
1338
      if (!tok->value) {
 
1339
        goto FORMAT_ERR;
 
1340
      }
 
1341
      if (!strcmp(tok->value, "true")) {
 
1342
        m_ele->direct = true;
 
1343
      } else if (!strcmp(tok->value, "false")) {
 
1344
        m_ele->direct = false;
 
1345
      } else {
 
1346
        goto FORMAT_ERR;
 
1347
      }
 
1348
    } else {
 
1349
      goto FORMAT_ERR;
 
1350
    }
 
1351
  }
 
1352
 
 
1353
  // the rule type should tell us whether go_direct or not
 
1354
  // the "go_direct" action tag recognization is done in get_rule_type
 
1355
  switch (m_ele->cfg_ele.type) {
 
1356
  case INK_PP_GO_DIRECT:
 
1357
    m_ele->direct = true;
 
1358
    break;
 
1359
  case INK_PP_PARENT:
 
1360
    m_ele->direct = false;
 
1361
    break;
 
1362
  default:
 
1363
    // Handled here:
 
1364
    // Lots of cases
 
1365
    break;
 
1366
  }
 
1367
 
 
1368
  return;
 
1369
 
 
1370
FORMAT_ERR:
 
1371
  m_valid = false;
 
1372
}
 
1373
 
 
1374
ParentProxyObj::~ParentProxyObj()
 
1375
{
 
1376
  INKParentProxyEleDestroy(m_ele);
 
1377
}
 
1378
 
 
1379
char *
 
1380
ParentProxyObj::formatEleToRule()
 
1381
{
 
1382
  if (!isValid()) {
 
1383
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
1384
    return NULL;
 
1385
  }
 
1386
 
 
1387
  char *pd_str, *list_str;
 
1388
  char buf[MAX_RULE_SIZE];
 
1389
  memset(buf, 0, MAX_RULE_SIZE);
 
1390
 
 
1391
  pd_str = pdest_sspec_to_string(m_ele->parent_info.pd_type, m_ele->parent_info.pd_val, &(m_ele->parent_info.sec_spec));
 
1392
  if (!pd_str)
 
1393
    return NULL;
 
1394
  strncat(buf, pd_str, sizeof(buf) - strlen(buf) - 1);
 
1395
  xfree(pd_str);
 
1396
 
 
1397
  // round_robin
 
1398
  if ((m_ele->rr != INK_RR_NONE) && (m_ele->rr != INK_RR_UNDEFINED)) {
 
1399
    if (!isspace(buf[strlen(buf) - 1])) {
 
1400
      strncat(buf, " ", sizeof(buf) - strlen(buf) - 1);
 
1401
    }
 
1402
    strncat(buf, "round_robin=", sizeof(buf) - strlen(buf) - 1);
 
1403
    switch (m_ele->rr) {
 
1404
    case INK_RR_TRUE:
 
1405
      strncat(buf, "true", sizeof(buf) - strlen(buf) - 1);
 
1406
      break;
 
1407
    case INK_RR_STRICT:
 
1408
      strncat(buf, "strict", sizeof(buf) - strlen(buf) - 1);
 
1409
      break;
 
1410
    case INK_RR_FALSE:
 
1411
      strncat(buf, "false", sizeof(buf) - strlen(buf) - 1);
 
1412
      break;
 
1413
    default:
 
1414
      // Handled here:
 
1415
      // INK_RR_NONE, INK_RR_UNDEFINED
 
1416
      break;
 
1417
    }
 
1418
  }
 
1419
 
 
1420
  if (m_ele->proxy_list != NULL) {
 
1421
    // include space delimiter if not already exist
 
1422
    if (!isspace(buf[strlen(buf) - 1])) {
 
1423
      strncat(buf, " ", sizeof(buf) - strlen(buf) - 1);
 
1424
    }
 
1425
    list_str = domain_list_to_string(m_ele->proxy_list, ";");
 
1426
    strncat(buf, "parent=\"", sizeof(buf) - strlen(buf) - 1);
 
1427
    if (list_str) {
 
1428
      strncat(buf, list_str, sizeof(buf) - strlen(buf) - 1);
 
1429
      xfree(list_str);
 
1430
    }
 
1431
    strncat(buf, "\"", sizeof(buf) - strlen(buf) - 1);
 
1432
 
 
1433
  }
 
1434
 
 
1435
  if (m_ele->direct) {
 
1436
    // include space delimiter if not already exist
 
1437
    if (!isspace(buf[strlen(buf) - 1])) {
 
1438
      strncat(buf, " ", sizeof(buf) - strlen(buf) - 1);
 
1439
    }
 
1440
    strncat(buf, "go_direct=true", sizeof(buf) - strlen(buf) - 1);
 
1441
  } else {
 
1442
    if (!isspace(buf[strlen(buf) - 1])) {
 
1443
      strncat(buf, " ", sizeof(buf) - strlen(buf) - 1);
 
1444
    }
 
1445
    strncat(buf, "go_direct=false", sizeof(buf) - strlen(buf) - 1);
 
1446
  }
 
1447
 
 
1448
  return xstrdup(buf);
 
1449
}
 
1450
 
 
1451
bool ParentProxyObj::isValid()
 
1452
{
 
1453
  if (m_ele->cfg_ele.error != INK_ERR_OKAY) {
 
1454
    m_valid = false;
 
1455
  }
 
1456
 
 
1457
  if (!ccu_checkPdSspec(m_ele->parent_info)) {
 
1458
    m_valid = false;
 
1459
  }
 
1460
 
 
1461
  if (m_ele->proxy_list && !INKDomainListIsValid(m_ele->proxy_list)) {
 
1462
    m_valid = false;
 
1463
  }
 
1464
 
 
1465
  if (!m_valid)
 
1466
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
1467
 
 
1468
  return m_valid;
 
1469
}
 
1470
 
 
1471
INKCfgEle *
 
1472
ParentProxyObj::getCfgEleCopy()
 
1473
{
 
1474
  return (INKCfgEle *) copy_parent_proxy_ele(m_ele);
 
1475
}
 
1476
 
 
1477
//--------------------------------------------------------------------------
 
1478
// PartitionObj
 
1479
//--------------------------------------------------------------------------
 
1480
PartitionObj::PartitionObj(INKPartitionEle * ele)
 
1481
{
 
1482
  m_ele = ele;
 
1483
  m_valid = true;
 
1484
  m_valid = isValid();
 
1485
}
 
1486
 
 
1487
PartitionObj::PartitionObj(TokenList * tokens)
 
1488
{
 
1489
  Token *token;
 
1490
 
 
1491
  m_ele = INKPartitionEleCreate();
 
1492
  m_ele->cfg_ele.error = INK_ERR_OKAY;
 
1493
  m_valid = true;
 
1494
 
 
1495
  if (!tokens || tokens->length != 3) {
 
1496
    goto FORMAT_ERR;
 
1497
  }
 
1498
 
 
1499
  m_ele->cfg_ele.type = get_rule_type(tokens, INK_FNAME_PARTITION);
 
1500
  if (m_ele->cfg_ele.type == INK_TYPE_UNDEFINED) {
 
1501
    goto FORMAT_ERR;
 
1502
  }
 
1503
 
 
1504
  token = tokens->first();
 
1505
  if (strcmp(token->name, "partition") || !token->value) {
 
1506
    goto FORMAT_ERR;
 
1507
  }
 
1508
  m_ele->partition_num = ink_atoi(token->value);
 
1509
 
 
1510
  token = tokens->next(token);
 
1511
  if (strcmp(token->name, "scheme") || !token->value) {
 
1512
    goto FORMAT_ERR;
 
1513
  }
 
1514
  if (!strcmp(token->value, "http")) {
 
1515
    m_ele->scheme = INK_PARTITION_HTTP;
 
1516
  } else {
 
1517
    m_ele->scheme = INK_PARTITION_UNDEFINED;
 
1518
  }
 
1519
 
 
1520
  token = tokens->next(token);
 
1521
  if (strcmp(token->name, "size") || !token->value) {
 
1522
    goto FORMAT_ERR;
 
1523
  }
 
1524
  // CAUTION: we may need a tigher error check
 
1525
  if (strstr(token->value, "%")) {
 
1526
    m_ele->size_format = INK_SIZE_FMT_PERCENT;
 
1527
  } else {
 
1528
    m_ele->size_format = INK_SIZE_FMT_ABSOLUTE;
 
1529
  }
 
1530
  m_ele->partition_size = ink_atoi(token->value);
 
1531
 
 
1532
  return;
 
1533
 
 
1534
FORMAT_ERR:
 
1535
  m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
1536
  m_valid = false;
 
1537
}
 
1538
 
 
1539
PartitionObj::~PartitionObj()
 
1540
{
 
1541
  INKPartitionEleDestroy(m_ele);
 
1542
}
 
1543
 
 
1544
char *
 
1545
PartitionObj::formatEleToRule()
 
1546
{
 
1547
  if (!isValid()) {
 
1548
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
1549
    return NULL;
 
1550
  }
 
1551
 
 
1552
  char buf[MAX_RULE_SIZE];
 
1553
  memset(buf, 0, MAX_RULE_SIZE);
 
1554
 
 
1555
  snprintf(buf, sizeof(buf), "partition=%d scheme=", m_ele->partition_num);
 
1556
 
 
1557
  switch (m_ele->scheme) {
 
1558
  case INK_PARTITION_HTTP:
 
1559
    strncat(buf, "http", sizeof(buf) - strlen(buf) - 1);
 
1560
    break;
 
1561
  default:
 
1562
    // Handled here:
 
1563
    // INK_PARTITION_UNDEFINED, INK_SIZE_FMT_ABSOLUTE, INK_SIZE_FMT_UNDEFINED
 
1564
    break;
 
1565
  }
 
1566
 
 
1567
  size_t pos = strlen(buf);
 
1568
  snprintf(buf + pos, sizeof(buf) - pos, " size=%d", m_ele->partition_size);
 
1569
  switch (m_ele->size_format) {
 
1570
  case INK_SIZE_FMT_PERCENT:
 
1571
    strncat(buf, "%", sizeof(buf) - strlen(buf) - 1);
 
1572
    break;
 
1573
  default:
 
1574
    // Handled here:
 
1575
    // INK_SIZE_FMT_ABSOLUTE, INK_SIZE_FMT_UNDEFINED
 
1576
    break;
 
1577
  }
 
1578
 
 
1579
  return xstrdup(buf);
 
1580
}
 
1581
 
 
1582
bool PartitionObj::isValid()
 
1583
{
 
1584
  if (m_ele->cfg_ele.error != INK_ERR_OKAY) {
 
1585
    m_valid = false;
 
1586
  }
 
1587
  // partition nubmer must be between 1-255 inclusive
 
1588
  if (m_ele->partition_num < 1 || m_ele->partition_num > 255) {
 
1589
    m_valid = false;
 
1590
  }
 
1591
 
 
1592
  switch (m_ele->scheme) {
 
1593
  case INK_PARTITION_HTTP:
 
1594
    break;
 
1595
  default:
 
1596
    m_valid = false;
 
1597
  }
 
1598
 
 
1599
  // absolute size must be multiple of 128; percentage size <= 100
 
1600
  if (m_ele->size_format == INK_SIZE_FMT_ABSOLUTE) {
 
1601
    if ((m_ele->partition_size < 0) || (m_ele->partition_size % 128)) {
 
1602
      m_valid = false;
 
1603
    }
 
1604
  } else if (m_ele->size_format == INK_SIZE_FMT_PERCENT) {
 
1605
    if ((m_ele->partition_size < 0) || (m_ele->partition_size > 100)) {
 
1606
      m_valid = false;
 
1607
    }
 
1608
  }
 
1609
 
 
1610
  if (!m_valid)
 
1611
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
1612
 
 
1613
  return m_valid;
 
1614
}
 
1615
 
 
1616
INKCfgEle *
 
1617
PartitionObj::getCfgEleCopy()
 
1618
{
 
1619
  return (INKCfgEle *) copy_partition_ele(m_ele);
 
1620
}
 
1621
 
 
1622
//--------------------------------------------------------------------------
 
1623
// PluginObj
 
1624
//--------------------------------------------------------------------------
 
1625
PluginObj::PluginObj(INKPluginEle * ele)
 
1626
{
 
1627
  m_ele = ele;
 
1628
  m_valid = true;
 
1629
  m_valid = isValid();
 
1630
}
 
1631
 
 
1632
PluginObj::PluginObj(TokenList * tokens)
 
1633
{
 
1634
  Token *token;
 
1635
 
 
1636
  m_ele = INKPluginEleCreate();
 
1637
  m_ele->cfg_ele.error = INK_ERR_OKAY;
 
1638
  m_valid = true;
 
1639
 
 
1640
  if (!tokens || tokens->length < 1) {
 
1641
    goto FORMAT_ERR;
 
1642
  }
 
1643
 
 
1644
  m_ele->cfg_ele.type = get_rule_type(tokens, INK_FNAME_PLUGIN);
 
1645
  if (m_ele->cfg_ele.type == INK_TYPE_UNDEFINED) {
 
1646
    goto FORMAT_ERR;
 
1647
  }
 
1648
  // plugin name
 
1649
  token = tokens->first();
 
1650
  if (strcmp(token->name, "") == 0) {
 
1651
    goto FORMAT_ERR;
 
1652
  }
 
1653
  m_ele->name = xstrdup(token->name);
 
1654
 
 
1655
  // arguments
 
1656
  token = tokens->next(token);
 
1657
  while (token) {
 
1658
    if (m_ele->args == INK_INVALID_LIST)
 
1659
      m_ele->args = INKStringListCreate();
 
1660
    if (token->name)
 
1661
      INKStringListEnqueue(m_ele->args, xstrdup(token->name));
 
1662
    token = tokens->next(token);
 
1663
  }
 
1664
 
 
1665
  return;
 
1666
 
 
1667
FORMAT_ERR:
 
1668
  m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
1669
  m_valid = false;
 
1670
}
 
1671
 
 
1672
PluginObj::~PluginObj()
 
1673
{
 
1674
  INKPluginEleDestroy(m_ele);
 
1675
}
 
1676
 
 
1677
char *
 
1678
PluginObj::formatEleToRule()
 
1679
{
 
1680
  if (!isValid()) {
 
1681
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
1682
    return NULL;
 
1683
  }
 
1684
 
 
1685
  char *list_str;
 
1686
  char buf[MAX_RULE_SIZE];
 
1687
  memset(buf, 0, MAX_RULE_SIZE);
 
1688
 
 
1689
  list_str = string_list_to_string(m_ele->args, " ");
 
1690
  if (list_str) {
 
1691
    snprintf(buf, sizeof(buf), "%s %s", m_ele->name, list_str);
 
1692
    xfree(list_str);
 
1693
  } else {
 
1694
    snprintf(buf, sizeof(buf), "%s", m_ele->name);
 
1695
  }
 
1696
 
 
1697
  return xstrdup(buf);
 
1698
}
 
1699
 
 
1700
bool PluginObj::isValid()
 
1701
{
 
1702
  if (m_ele->cfg_ele.error != INK_ERR_OKAY) {
 
1703
    m_valid = false;
 
1704
  }
 
1705
  // check plugin name
 
1706
  if (!m_ele->name || strcmp(m_ele->name, "") == 0) {
 
1707
    m_valid = false;
 
1708
  }
 
1709
 
 
1710
  return m_valid;
 
1711
}
 
1712
 
 
1713
INKCfgEle *
 
1714
PluginObj::getCfgEleCopy()
 
1715
{
 
1716
  return (INKCfgEle *) copy_plugin_ele(m_ele);
 
1717
}
 
1718
 
 
1719
 
 
1720
//--------------------------------------------------------------------------
 
1721
// RemapObj
 
1722
//--------------------------------------------------------------------------
 
1723
RemapObj::RemapObj(INKRemapEle * ele)
 
1724
{
 
1725
  m_ele = ele;
 
1726
  m_valid = true;
 
1727
  m_valid = isValid();
 
1728
}
 
1729
 
 
1730
RemapObj::RemapObj(TokenList * tokens)
 
1731
{
 
1732
  Token *token;
 
1733
  short current;                // current token index
 
1734
  Tokenizer fromTok(":/");
 
1735
  Tokenizer toTok(":/");
 
1736
  char buf[MAX_RULE_SIZE];
 
1737
 
 
1738
  m_ele = INKRemapEleCreate(INK_TYPE_UNDEFINED);
 
1739
  m_ele->cfg_ele.error = INK_ERR_OKAY;
 
1740
  m_valid = true;
 
1741
 
 
1742
  if (!tokens || ((tokens->length != 2) && (tokens->length != 3))) {
 
1743
    goto FORMAT_ERR;
 
1744
  }
 
1745
 
 
1746
  m_ele->cfg_ele.type = get_rule_type(tokens, INK_FNAME_REMAP);
 
1747
  if (m_ele->cfg_ele.type == INK_TYPE_UNDEFINED) {
 
1748
    goto FORMAT_ERR;
 
1749
  }
 
1750
  // The first token must either be "map, "reverse_map", "redirect", and redirect_temporary
 
1751
  token = tokens->first();
 
1752
 
 
1753
  // target
 
1754
  token = tokens->next(token);
 
1755
 
 
1756
  if (!ccu_checkUrl(token->name)) {
 
1757
    goto FORMAT_ERR;
 
1758
  }
 
1759
 
 
1760
  // TODO: Should we check the return value (count) here?
 
1761
  fromTok.Initialize(token->name, ALLOW_EMPTY_TOKS);       // allow empty token for parse sanity check
 
1762
 
 
1763
  if (strcmp(fromTok[0], "http") == 0) {
 
1764
    m_ele->from_scheme = INK_SCHEME_HTTP;
 
1765
  } else if (strcmp(fromTok[0], "https") == 0) {
 
1766
    m_ele->from_scheme = INK_SCHEME_HTTPS;
 
1767
  } else if (strcmp(fromTok[0], "rtsp") == 0) {
 
1768
    m_ele->from_scheme = INK_SCHEME_RTSP;
 
1769
  } else if (strcmp(fromTok[0], "mms") == 0) {
 
1770
    m_ele->from_scheme = INK_SCHEME_MMS;
 
1771
  } else {
 
1772
    m_ele->from_scheme = INK_SCHEME_UNDEFINED;
 
1773
    goto FORMAT_ERR;
 
1774
  }
 
1775
 
 
1776
  // from host
 
1777
  m_ele->from_host = xstrdup(fromTok[3]);
 
1778
 
 
1779
  current = 4;
 
1780
  if (fromTok[4]) {
 
1781
 
 
1782
    // from port
 
1783
    m_ele->from_port = ink_atoi(fromTok[4]);
 
1784
    if (m_ele->from_port != 0) {        // Does it have a port
 
1785
      current++;
 
1786
    } else {                    // No ports
 
1787
      m_ele->from_port = INK_INVALID_PORT;
 
1788
    }
 
1789
 
 
1790
    // from prefix
 
1791
    if (fromTok[current]) {
 
1792
 
 
1793
      memset(buf, 0, MAX_RULE_SIZE);
 
1794
 
 
1795
      for (int i = current; fromTok[i]; i++) {
 
1796
        strncat(buf, fromTok[i], sizeof(buf) - strlen(buf) - 1);
 
1797
        strncat(buf, "/", sizeof(buf) - strlen(buf) - 1);
 
1798
      }
 
1799
 
 
1800
      if ((token->name)[strlen(token->name) - 1] != '/') {
 
1801
        buf[strlen(buf) - 1] = '\0';    // truncate the last '/'
 
1802
      }
 
1803
 
 
1804
      m_ele->from_path_prefix = xstrdup(buf);
 
1805
    }
 
1806
  } else {
 
1807
    if ((token->name)[strlen(token->name) - 1] == '/') {
 
1808
      memset(buf, 0, MAX_RULE_SIZE);
 
1809
      ink_strncpy(buf, m_ele->from_host, sizeof(buf));
 
1810
      xfree(m_ele->from_host);
 
1811
      strncat(buf, "/", sizeof(buf) - strlen(buf) - 1);
 
1812
      m_ele->from_host = xstrdup(buf);
 
1813
    }
 
1814
  }
 
1815
 
 
1816
  if (!ccu_checkUrl(token->value)) {
 
1817
    goto FORMAT_ERR;
 
1818
  }
 
1819
 
 
1820
  // TODO: Should we check the return value (count) here?
 
1821
  toTok.Initialize(token->value, ALLOW_EMPTY_TOKS);  // allow empty token for parse sanity check
 
1822
 
 
1823
  if (strcmp(toTok[0], "http") == 0) {
 
1824
    m_ele->to_scheme = INK_SCHEME_HTTP;
 
1825
  } else if (strcmp(toTok[0], "https") == 0) {
 
1826
    m_ele->to_scheme = INK_SCHEME_HTTPS;
 
1827
  } else if (strcmp(toTok[0], "rtsp") == 0) {
 
1828
    m_ele->to_scheme = INK_SCHEME_RTSP;
 
1829
  } else if (strcmp(toTok[0], "mms") == 0) {
 
1830
    m_ele->to_scheme = INK_SCHEME_MMS;
 
1831
  } else {
 
1832
    m_ele->to_scheme = INK_SCHEME_UNDEFINED;
 
1833
    goto FORMAT_ERR;
 
1834
  }
 
1835
 
 
1836
  // to host
 
1837
  m_ele->to_host = xstrdup(toTok[3]);
 
1838
 
 
1839
  current = 4;
 
1840
  if (toTok[4]) {
 
1841
 
 
1842
    // to port
 
1843
    m_ele->to_port = ink_atoi(toTok[4]);
 
1844
    if (m_ele->to_port != 0) {  // Does it have a port
 
1845
      current++;
 
1846
    } else {                    // No ports
 
1847
      m_ele->to_port = INK_INVALID_PORT;
 
1848
    }
 
1849
 
 
1850
    // to prefix
 
1851
    if (toTok[current]) {
 
1852
 
 
1853
      memset(buf, 0, MAX_RULE_SIZE);
 
1854
 
 
1855
      for (int i = current; toTok[i]; i++) {
 
1856
        strncat(buf, toTok[i], sizeof(buf) - strlen(buf) - 1);
 
1857
        strncat(buf, "/", sizeof(buf) - strlen(buf) - 1);
 
1858
      }
 
1859
 
 
1860
      if ((token->name)[strlen(token->name) - 1] != '/') {
 
1861
        buf[strlen(buf) - 1] = '\0';    // truncate the last '/'
 
1862
      }
 
1863
 
 
1864
      m_ele->to_path_prefix = xstrdup(buf);
 
1865
    }
 
1866
  } else {
 
1867
    if ((token->value)[strlen(token->value) - 1] == '/') {
 
1868
 
 
1869
      memset(buf, 0, MAX_RULE_SIZE);
 
1870
      ink_strncpy(buf, m_ele->to_host, sizeof(buf));
 
1871
      xfree(m_ele->to_host);
 
1872
      strncat(buf, "/", sizeof(buf) - strlen(buf) - 1);
 
1873
      m_ele->to_host = xstrdup(buf);
 
1874
 
 
1875
    }
 
1876
  }
 
1877
 
 
1878
  return;
 
1879
 
 
1880
FORMAT_ERR:
 
1881
  m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
1882
  m_valid = false;
 
1883
}
 
1884
 
 
1885
RemapObj::~RemapObj()
 
1886
{
 
1887
  INKRemapEleDestroy(m_ele);
 
1888
}
 
1889
 
 
1890
char *
 
1891
RemapObj::formatEleToRule()
 
1892
{
 
1893
  if (!isValid()) {
 
1894
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
1895
    return NULL;
 
1896
  }
 
1897
 
 
1898
  char buf[MAX_RULE_SIZE];
 
1899
  memset(buf, 0, MAX_RULE_SIZE);
 
1900
 
 
1901
  switch (m_ele->cfg_ele.type) {
 
1902
  case INK_REMAP_MAP:
 
1903
    strncat(buf, "map", sizeof(buf) - strlen(buf) - 1);
 
1904
    break;
 
1905
  case INK_REMAP_REVERSE_MAP:
 
1906
    strncat(buf, "reverse_map", sizeof(buf) - strlen(buf) - 1);
 
1907
    break;
 
1908
  case INK_REMAP_REDIRECT:
 
1909
    strncat(buf, "redirect", sizeof(buf) - strlen(buf) - 1);
 
1910
    break;
 
1911
  case INK_REMAP_REDIRECT_TEMP:
 
1912
    strncat(buf, "redirect_temporary", sizeof(buf) - strlen(buf) - 1);
 
1913
    break;
 
1914
  default:
 
1915
    // Handled here:
 
1916
    // Lots of cases...
 
1917
    break;
 
1918
  }
 
1919
  // space delimitor
 
1920
  strncat(buf, " ", sizeof(buf) - strlen(buf) - 1);
 
1921
 
 
1922
  // from scheme
 
1923
  switch (m_ele->from_scheme) {
 
1924
  case INK_SCHEME_HTTP:
 
1925
    strncat(buf, "http", sizeof(buf) - strlen(buf) - 1);
 
1926
    break;
 
1927
  case INK_SCHEME_HTTPS:
 
1928
    strncat(buf, "https", sizeof(buf) - strlen(buf) - 1);
 
1929
    break;
 
1930
  case INK_SCHEME_RTSP:
 
1931
    strncat(buf, "rtsp", sizeof(buf) - strlen(buf) - 1);
 
1932
    break;
 
1933
  case INK_SCHEME_MMS:
 
1934
    strncat(buf, "mms", sizeof(buf) - strlen(buf) - 1);
 
1935
    break;
 
1936
  default:
 
1937
    // Handled here:
 
1938
    // INK_SCHEME_NONE, INK_SCHEME_UNDEFINED
 
1939
    break;
 
1940
  }
 
1941
  strncat(buf, "://", sizeof(buf) - strlen(buf) - 1);
 
1942
 
 
1943
  // from host
 
1944
  if (m_ele->from_host) {
 
1945
    strncat(buf, m_ele->from_host, sizeof(buf) - strlen(buf) - 1);
 
1946
  }
 
1947
  // from port
 
1948
  if (m_ele->from_port != INK_INVALID_PORT) {
 
1949
    snprintf(buf, sizeof(buf), "%s:%d", buf, m_ele->from_port);
 
1950
  }
 
1951
  // from host path
 
1952
  if (m_ele->from_path_prefix) {
 
1953
    strncat(buf, "/", sizeof(buf) - strlen(buf) - 1);
 
1954
    strncat(buf, m_ele->from_path_prefix, sizeof(buf) - strlen(buf) - 1);
 
1955
  }
 
1956
  // space delimitor
 
1957
  strncat(buf, " ", sizeof(buf) - strlen(buf) - 1);
 
1958
 
 
1959
  // to scheme
 
1960
  switch (m_ele->to_scheme) {
 
1961
  case INK_SCHEME_HTTP:
 
1962
    strncat(buf, "http", sizeof(buf) - strlen(buf) - 1);
 
1963
    break;
 
1964
  case INK_SCHEME_HTTPS:
 
1965
    strncat(buf, "https", sizeof(buf) - strlen(buf) - 1);
 
1966
    break;
 
1967
  case INK_SCHEME_RTSP:
 
1968
    strncat(buf, "rtsp", sizeof(buf) - strlen(buf) - 1);
 
1969
    break;
 
1970
  case INK_SCHEME_MMS:
 
1971
    strncat(buf, "mms", sizeof(buf) - strlen(buf) - 1);
 
1972
    break;
 
1973
  default:
 
1974
    // Handled here:
 
1975
    // INK_SCHEME_NONE, INK_SCHEME_UNDEFINED
 
1976
    break;
 
1977
  }
 
1978
  strncat(buf, "://", sizeof(buf) - strlen(buf) - 1);
 
1979
 
 
1980
  // to host
 
1981
  if (m_ele->to_host) {
 
1982
    strncat(buf, m_ele->to_host, sizeof(buf) - strlen(buf) - 1);
 
1983
  }
 
1984
  // to port
 
1985
  if (m_ele->to_port != INK_INVALID_PORT) {
 
1986
    snprintf(buf, sizeof(buf), "%s:%d", buf, m_ele->to_port);
 
1987
  }
 
1988
  // to host path
 
1989
  if (m_ele->to_path_prefix) {
 
1990
    strncat(buf, "/", sizeof(buf) - strlen(buf) - 1);
 
1991
    strncat(buf, m_ele->to_path_prefix, sizeof(buf) - strlen(buf) - 1);
 
1992
  }
 
1993
 
 
1994
  return xstrdup(buf);
 
1995
}
 
1996
 
 
1997
bool RemapObj::isValid()
 
1998
{
 
1999
  if (m_ele->cfg_ele.error != INK_ERR_OKAY) {
 
2000
    m_valid = false;
 
2001
  }
 
2002
  // rule type
 
2003
  switch (m_ele->cfg_ele.type) {
 
2004
  case INK_REMAP_MAP:
 
2005
  case INK_REMAP_REVERSE_MAP:
 
2006
  case INK_REMAP_REDIRECT:
 
2007
  case INK_REMAP_REDIRECT_TEMP:
 
2008
    break;
 
2009
  default:
 
2010
    m_valid = false;
 
2011
  }
 
2012
 
 
2013
  // from scheme
 
2014
  switch (m_ele->from_scheme) {
 
2015
  case INK_SCHEME_HTTP:
 
2016
  case INK_SCHEME_HTTPS:
 
2017
  case INK_SCHEME_RTSP:
 
2018
  case INK_SCHEME_MMS:
 
2019
    break;
 
2020
  default:
 
2021
    m_valid = false;
 
2022
  }
 
2023
 
 
2024
  switch (m_ele->to_scheme) {
 
2025
  case INK_SCHEME_HTTP:
 
2026
  case INK_SCHEME_HTTPS:
 
2027
  case INK_SCHEME_RTSP:
 
2028
  case INK_SCHEME_MMS:
 
2029
    break;
 
2030
  default:
 
2031
    m_valid = false;
 
2032
  }
 
2033
 
 
2034
  // mandatory field
 
2035
  if (!m_ele->from_host || strstr(m_ele->from_host, ":/")) {
 
2036
    m_valid = false;
 
2037
  }
 
2038
  // mandatory field
 
2039
  if (!m_ele->to_host || strstr(m_ele->to_host, ":/")) {
 
2040
    m_valid = false;
 
2041
  }
 
2042
 
 
2043
  if ((m_ele->from_path_prefix && strstr(m_ele->from_path_prefix, ":")) ||
 
2044
      (m_ele->to_path_prefix && strstr(m_ele->to_path_prefix, ":"))) {
 
2045
    m_valid = false;
 
2046
  }
 
2047
 
 
2048
  if (!m_valid)
 
2049
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
2050
 
 
2051
  return m_valid;
 
2052
}
 
2053
 
 
2054
INKCfgEle *
 
2055
RemapObj::getCfgEleCopy()
 
2056
{
 
2057
  return (INKCfgEle *) copy_remap_ele(m_ele);
 
2058
}
 
2059
 
 
2060
//--------------------------------------------------------------------------
 
2061
// SocksObj
 
2062
//--------------------------------------------------------------------------
 
2063
SocksObj::SocksObj(INKSocksEle * ele)
 
2064
{
 
2065
  m_ele = ele;
 
2066
  m_valid = true;
 
2067
  m_valid = isValid();
 
2068
}
 
2069
 
 
2070
SocksObj::SocksObj(TokenList * tokens)
 
2071
{
 
2072
  Token *tok;
 
2073
 
 
2074
  m_ele = INKSocksEleCreate(INK_TYPE_UNDEFINED);
 
2075
  m_ele->cfg_ele.error = INK_ERR_OKAY;
 
2076
  m_valid = true;
 
2077
 
 
2078
  if (!tokens) {
 
2079
    goto FORMAT_ERR;
 
2080
  }
 
2081
 
 
2082
  m_ele->cfg_ele.type = get_rule_type(tokens, INK_FNAME_SOCKS);
 
2083
  if (m_ele->cfg_ele.type == INK_TYPE_UNDEFINED) {
 
2084
    goto FORMAT_ERR;
 
2085
  }
 
2086
  // Determine if it's  a "no-socks" rule or a "parent socks servers" rule
 
2087
  tok = tokens->first();
 
2088
  if (strcmp(tok->name, "no_socks") == 0) {     // no-socks rule; INK_SOCKS_BYPASS
 
2089
 
 
2090
    if (m_ele->ip_addrs != NULL) {
 
2091
      goto FORMAT_ERR;
 
2092
    }
 
2093
    m_ele->ip_addrs = string_to_ip_addr_list(tok->value, ",");
 
2094
  } else if (strcmp(tok->name, "auth") == 0) {  // INK_SOCKS_AUTH rule
 
2095
    if (strcmp(tok->value, "u") == 0) {
 
2096
      tok = tokens->next(tok);
 
2097
      if (tok && tok->name) {
 
2098
        m_ele->username = xstrdup(tok->name);
 
2099
      } else {
 
2100
        goto FORMAT_ERR;
 
2101
      }
 
2102
      if (tok && tok->name) {
 
2103
        tok = tokens->next(tok);
 
2104
        m_ele->password = xstrdup(tok->name);
 
2105
      } else {
 
2106
        goto FORMAT_ERR;
 
2107
      }
 
2108
    } else {
 
2109
      goto FORMAT_ERR;
 
2110
    }
 
2111
  } else {                      // multiple socks servers rule; INK_SOCKS_MULTIPLE
 
2112
    // should be dest_ip tag
 
2113
    if (strcmp(tok->name, "dest_ip") == 0) {
 
2114
      m_ele->dest_ip_addr = string_to_ip_addr_ele(tok->value);
 
2115
    } else {
 
2116
      goto FORMAT_ERR;
 
2117
    }
 
2118
 
 
2119
    // search dest_ip, parent and round_robin action tags
 
2120
    for (tok = tokens->next(tok); tok; tok = tokens->next(tok)) {
 
2121
      if (strcmp(tok->name, "round_robin") == 0) {
 
2122
        // sanity check
 
2123
        if (!tok->value) {
 
2124
          goto FORMAT_ERR;
 
2125
        }
 
2126
 
 
2127
        if (strcmp(tok->value, "true") == 0) {
 
2128
          m_ele->rr = INK_RR_TRUE;
 
2129
        } else if (strcmp(tok->value, "strict") == 0) {
 
2130
          m_ele->rr = INK_RR_STRICT;
 
2131
        } else if (strcmp(tok->value, "false") == 0) {
 
2132
          m_ele->rr = INK_RR_FALSE;
 
2133
        } else {
 
2134
          m_ele->rr = INK_RR_NONE;
 
2135
          goto FORMAT_ERR;      // missing value for round_robin tag
 
2136
        }
 
2137
 
 
2138
      } else if (strcmp(tok->name, "parent") == 0) {
 
2139
        // sanity check
 
2140
        if (!tok->value) {
 
2141
          goto FORMAT_ERR;
 
2142
        }
 
2143
        m_ele->socks_servers = string_to_domain_list(tok->value, ";");
 
2144
      }
 
2145
    }                           // end for loop
 
2146
 
 
2147
  }
 
2148
 
 
2149
  return;
 
2150
 
 
2151
FORMAT_ERR:
 
2152
  m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
2153
  m_valid = false;
 
2154
}
 
2155
 
 
2156
SocksObj::~SocksObj()
 
2157
{
 
2158
  INKSocksEleDestroy(m_ele);
 
2159
}
 
2160
 
 
2161
char *
 
2162
SocksObj::formatEleToRule()
 
2163
{
 
2164
  if (!isValid()) {
 
2165
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
2166
    return NULL;
 
2167
  }
 
2168
  char buf[MAX_RULE_SIZE];
 
2169
  memset(buf, 0, MAX_RULE_SIZE);
 
2170
 
 
2171
  if (m_ele->ip_addrs != NULL) {        // INK_SOCKS_BYPASS rule
 
2172
    char *str_list = ip_addr_list_to_string((LLQ *) m_ele->ip_addrs, ",");
 
2173
    if (str_list) {
 
2174
      snprintf(buf, sizeof(buf), "no_socks %s", str_list);
 
2175
      xfree(str_list);
 
2176
    } else {
 
2177
      return NULL;              // invalid ip_addr_list
 
2178
    }
 
2179
  } else if (m_ele->username != NULL) { // INK_SOCKS_AUTH rule
 
2180
    snprintf(buf, sizeof(buf), "auth u %s %s", m_ele->username, m_ele->password);
 
2181
  } else {                      // INK_SOCKS_MULTIPLE rule
 
2182
    // destination ip
 
2183
    char *ip_str = ip_addr_ele_to_string((INKIpAddrEle *) m_ele->dest_ip_addr);
 
2184
    if (ip_str) {
 
2185
      strncat(buf, "dest_ip=", sizeof(buf) - strlen(buf) - 1);
 
2186
      strncat(buf, ip_str, sizeof(buf) - strlen(buf) - 1);
 
2187
      xfree(ip_str);
 
2188
    } else {
 
2189
      return NULL;              // invalid IP
 
2190
    }
 
2191
 
 
2192
    // parent server list
 
2193
    if (m_ele->socks_servers != NULL) {
 
2194
      // include space delimiter if not already exist
 
2195
      if (!isspace(buf[strlen(buf) - 1])) {
 
2196
        strncat(buf, " ", sizeof(buf) - strlen(buf) - 1);
 
2197
      }
 
2198
      char *list_str = domain_list_to_string(m_ele->socks_servers, ";");
 
2199
      if (list_str) {
 
2200
        strncat(buf, "parent=\"", sizeof(buf) - strlen(buf) - 1);
 
2201
        strncat(buf, list_str, sizeof(buf) - strlen(buf) - 1);
 
2202
        strncat(buf, "\"", sizeof(buf) - strlen(buf) - 1);
 
2203
        xfree(list_str);
 
2204
      } else {
 
2205
        return NULL;            // invalid list
 
2206
      }
 
2207
    }
 
2208
    // round-robin, if specified
 
2209
    if ((m_ele->rr != INK_RR_NONE) && (m_ele->rr != INK_RR_UNDEFINED)) {
 
2210
      if (!isspace(buf[strlen(buf) - 1])) {
 
2211
        strncat(buf, " ", sizeof(buf) - strlen(buf) - 1);
 
2212
      }
 
2213
      strncat(buf, "round_robin=", sizeof(buf) - strlen(buf) - 1);
 
2214
      switch (m_ele->rr) {
 
2215
      case INK_RR_TRUE:
 
2216
        strncat(buf, "true", sizeof(buf) - strlen(buf) - 1);
 
2217
        break;
 
2218
      case INK_RR_STRICT:
 
2219
        strncat(buf, "strict", sizeof(buf) - strlen(buf) - 1);
 
2220
        break;
 
2221
      case INK_RR_FALSE:
 
2222
        strncat(buf, "false", sizeof(buf) - strlen(buf) - 1);
 
2223
        break;
 
2224
      default:
 
2225
        // Handled here:
 
2226
        // INK_RR_NONE, INK_RR_UNDEFINED
 
2227
        break;
 
2228
      }
 
2229
    }
 
2230
  }
 
2231
 
 
2232
  return xstrdup(buf);
 
2233
}
 
2234
 
 
2235
// the rule must either have an ip addr list (exclusive) OR
 
2236
// the dest_ip_addr * socks_servers OR
 
2237
// the username and password
 
2238
bool SocksObj::isValid()
 
2239
{
 
2240
  if (m_ele->cfg_ele.error != INK_ERR_OKAY) {
 
2241
    m_valid = false;
 
2242
  }
 
2243
 
 
2244
  switch (m_ele->cfg_ele.type) {
 
2245
  case INK_SOCKS_BYPASS:
 
2246
    if (m_ele->dest_ip_addr || m_ele->username || m_ele->password || !INKIpAddrListIsValid(m_ele->ip_addrs)) {
 
2247
      m_valid = false;
 
2248
    } else {
 
2249
      m_valid = true;
 
2250
    }
 
2251
    break;
 
2252
  case INK_SOCKS_AUTH:
 
2253
    if (m_ele->username == NULL || m_ele->password == NULL || m_ele->ip_addrs || m_ele->dest_ip_addr) {
 
2254
      m_valid = false;
 
2255
    } else {
 
2256
      m_valid = true;
 
2257
    }
 
2258
    break;
 
2259
  case INK_SOCKS_MULTIPLE:
 
2260
    if (m_ele->ip_addrs || m_ele->username ||
 
2261
        !(m_ele->dest_ip_addr && m_ele->socks_servers) ||
 
2262
        !ccu_checkIpAddrEle(m_ele->dest_ip_addr) || !INKDomainListIsValid(m_ele->socks_servers)) {
 
2263
      m_valid = false;
 
2264
    } else {
 
2265
      m_valid = true;
 
2266
    }
 
2267
    break;
 
2268
  default:
 
2269
    m_valid = false;
 
2270
    break;
 
2271
  }
 
2272
 
 
2273
  if (!m_valid)
 
2274
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
2275
 
 
2276
  return m_valid;
 
2277
}
 
2278
 
 
2279
INKCfgEle *
 
2280
SocksObj::getCfgEleCopy()
 
2281
{
 
2282
  return (INKCfgEle *) copy_socks_ele(m_ele);
 
2283
}
 
2284
 
 
2285
//--------------------------------------------------------------------------
 
2286
// SplitDnsObj
 
2287
//--------------------------------------------------------------------------
 
2288
SplitDnsObj::SplitDnsObj(INKSplitDnsEle * ele)
 
2289
{
 
2290
  m_ele = ele;
 
2291
  m_valid = true;
 
2292
  m_valid = isValid();
 
2293
}
 
2294
 
 
2295
SplitDnsObj::SplitDnsObj(TokenList * tokens)
 
2296
{
 
2297
  Token *tok;
 
2298
 
 
2299
  m_ele = INKSplitDnsEleCreate();
 
2300
  m_ele->cfg_ele.error = INK_ERR_OKAY;
 
2301
  m_valid = true;
 
2302
 
 
2303
  if (!tokens || (tokens->length > 6)) {
 
2304
    goto FORMAT_ERR;
 
2305
  }
 
2306
 
 
2307
  m_ele->cfg_ele.type = get_rule_type(tokens, INK_FNAME_SPLIT_DNS);
 
2308
  if (m_ele->cfg_ele.type == INK_TYPE_UNDEFINED) {
 
2309
    goto FORMAT_ERR;
 
2310
  }
 
2311
 
 
2312
  tok = tokens->first();
 
2313
  while (tok) {
 
2314
    if (!strcmp(tok->name, "dest_domain")) {
 
2315
      if ((m_ele->pd_type != INK_PD_UNDEFINED) || (m_ele->pd_val != NULL) || (!tok->value)) {
 
2316
        // fields are already defined!!
 
2317
        goto FORMAT_ERR;
 
2318
      }
 
2319
      m_ele->pd_type = INK_PD_DOMAIN;
 
2320
      m_ele->pd_val = xstrdup(tok->value);
 
2321
    } else if (strcmp(tok->name, "dest_host") == 0) {
 
2322
      if ((m_ele->pd_type != INK_PD_UNDEFINED) || (m_ele->pd_val != NULL) || (!tok->value)) {
 
2323
        // fields are already defined!!
 
2324
        goto FORMAT_ERR;
 
2325
      }
 
2326
      m_ele->pd_type = INK_PD_HOST;
 
2327
      m_ele->pd_val = xstrdup(tok->value);
 
2328
    } else if (strcmp(tok->name, "url_regex") == 0) {
 
2329
      if ((m_ele->pd_type != INK_PD_UNDEFINED) || (m_ele->pd_val != NULL) || (!tok->value)) {
 
2330
        // fields are already defined!!
 
2331
        goto FORMAT_ERR;
 
2332
      }
 
2333
      m_ele->pd_type = INK_PD_URL_REGEX;
 
2334
      m_ele->pd_val = xstrdup(tok->value);
 
2335
    } else if (strcmp(tok->name, "named") == 0) {
 
2336
      if ((m_ele->dns_servers_addrs != NULL) || (!tok->value)) {
 
2337
        // fields are already defined!!
 
2338
        goto FORMAT_ERR;
 
2339
      }
 
2340
      m_ele->dns_servers_addrs = (INKDomainList) string_to_domain_list(tok->value, "; ");
 
2341
    } else if (strcmp(tok->name, "def_domain") == 0) {
 
2342
      if ((m_ele->def_domain != NULL) || (!tok->value)) {
 
2343
        // fields are already defined!!
 
2344
        goto FORMAT_ERR;
 
2345
      }
 
2346
      m_ele->def_domain = xstrdup(tok->value);
 
2347
    } else if (strcmp(tok->name, "search_list") == 0) {
 
2348
      if ((m_ele->search_list != NULL) || (!tok->value)) {
 
2349
        // fields are already defined!!
 
2350
        goto FORMAT_ERR;
 
2351
      }
 
2352
      m_ele->search_list = (INKDomainList) string_to_domain_list(tok->value, "; ");
 
2353
    } else {
 
2354
      // Not able to recongize token name
 
2355
      goto FORMAT_ERR;
 
2356
    }
 
2357
 
 
2358
    tok = tokens->next(tok);
 
2359
  }
 
2360
  return;
 
2361
 
 
2362
FORMAT_ERR:
 
2363
  m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
2364
  m_valid = false;
 
2365
}
 
2366
 
 
2367
SplitDnsObj::~SplitDnsObj()
 
2368
{
 
2369
  INKSplitDnsEleDestroy(m_ele);
 
2370
}
 
2371
 
 
2372
char *
 
2373
SplitDnsObj::formatEleToRule()
 
2374
{
 
2375
  if (!isValid()) {
 
2376
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
2377
    return NULL;
 
2378
  }
 
2379
 
 
2380
  char buf[MAX_RULE_SIZE];
 
2381
  memset(buf, 0, MAX_RULE_SIZE);
 
2382
 
 
2383
  char *pd_name;
 
2384
  switch (m_ele->pd_type) {
 
2385
  case INK_PD_DOMAIN:
 
2386
    pd_name = xstrdup("dest_domain");
 
2387
    break;
 
2388
  case INK_PD_HOST:
 
2389
    pd_name = xstrdup("dest_host");
 
2390
    break;
 
2391
  case INK_PD_URL_REGEX:
 
2392
    pd_name = xstrdup("url_regex");
 
2393
    break;
 
2394
  default:
 
2395
    pd_name = xstrdup("");      // lv: just to make this junk workable
 
2396
    // Handled here:
 
2397
    // INK_PD_IP, INK_PD_UNDEFINED
 
2398
    break;
 
2399
  }
 
2400
 
 
2401
  if (m_ele->pd_val) {
 
2402
    strncat(buf, pd_name, sizeof(buf) - strlen(buf) - 1);
 
2403
    strncat(buf, "=", sizeof(buf) - strlen(buf) - 1);
 
2404
    if (strstr(m_ele->pd_val, " ")) {
 
2405
      strncat(buf, "\"", sizeof(buf) - strlen(buf) - 1);
 
2406
    }
 
2407
    strncat(buf, m_ele->pd_val, sizeof(buf) - strlen(buf) - 1);
 
2408
    if (strstr(m_ele->pd_val, " ")) {
 
2409
      strncat(buf, "\"", sizeof(buf) - strlen(buf) - 1);
 
2410
    }
 
2411
    strncat(buf, " ", sizeof(buf) - strlen(buf) - 1);
 
2412
  }
 
2413
 
 
2414
  if (m_ele->dns_servers_addrs) {
 
2415
    strncat(buf, "named=", sizeof(buf) - strlen(buf) - 1);
 
2416
    char *temp = domain_list_to_string((LLQ *) m_ele->dns_servers_addrs, ";");
 
2417
    if (temp) {
 
2418
      if (strstr(temp, " ")) {
 
2419
        strncat(buf, "\"", sizeof(buf) - strlen(buf) - 1);
 
2420
      }
 
2421
      strncat(buf, temp, sizeof(buf) - strlen(buf) - 1);
 
2422
      if (strstr(temp, " ")) {
 
2423
        strncat(buf, "\"", sizeof(buf) - strlen(buf) - 1);
 
2424
      }
 
2425
      xfree(temp);
 
2426
    }
 
2427
    strncat(buf, " ", sizeof(buf) - strlen(buf) - 1);
 
2428
  }
 
2429
 
 
2430
  if (m_ele->def_domain) {
 
2431
    strncat(buf, "def_domain=", sizeof(buf) - strlen(buf) - 1);
 
2432
    if (strstr(m_ele->def_domain, " ")) {
 
2433
      strncat(buf, "\"", sizeof(buf) - strlen(buf) - 1);
 
2434
    }
 
2435
    strncat(buf, m_ele->def_domain, sizeof(buf) - strlen(buf) - 1);
 
2436
    if (strstr(m_ele->def_domain, " ")) {
 
2437
      strncat(buf, "\"", sizeof(buf) - strlen(buf) - 1);
 
2438
    }
 
2439
    strncat(buf, " ", sizeof(buf) - strlen(buf) - 1);
 
2440
  }
 
2441
 
 
2442
  if (m_ele->search_list) {
 
2443
    strncat(buf, "search_list=", sizeof(buf) - strlen(buf) - 1);
 
2444
    char *temp = domain_list_to_string(m_ele->search_list, ";");
 
2445
    if (temp) {
 
2446
      if (strstr(temp, " ")) {
 
2447
        strncat(buf, "\"", sizeof(buf) - strlen(buf) - 1);
 
2448
      }
 
2449
      strncat(buf, temp, sizeof(buf) - strlen(buf) - 1);
 
2450
      if (strstr(temp, " ")) {
 
2451
        strncat(buf, "\"", sizeof(buf) - strlen(buf) - 1);
 
2452
      }
 
2453
      xfree(temp);
 
2454
    }
 
2455
    strncat(buf, " ", sizeof(buf) - strlen(buf) - 1);
 
2456
  }
 
2457
  // chop the last space
 
2458
  while (isspace(buf[strlen(buf) - 1])) {
 
2459
    buf[strlen(buf) - 1] = '\0';
 
2460
  }
 
2461
 
 
2462
  if (pd_name)
 
2463
    xfree(pd_name);
 
2464
 
 
2465
  return xstrdup(buf);
 
2466
}
 
2467
 
 
2468
bool SplitDnsObj::isValid()
 
2469
{
 
2470
  if (m_ele->cfg_ele.error != INK_ERR_OKAY) {
 
2471
    m_valid = false;
 
2472
  }
 
2473
 
 
2474
  switch (m_ele->pd_type) {
 
2475
  case INK_PD_DOMAIN:
 
2476
  case INK_PD_HOST:
 
2477
  case INK_PD_URL_REGEX:
 
2478
    break;
 
2479
  default:
 
2480
    m_valid = false;
 
2481
  }
 
2482
 
 
2483
  if (!m_ele->pd_val) {
 
2484
    m_valid = false;
 
2485
  }
 
2486
 
 
2487
  if (!INKDomainListIsValid(m_ele->dns_servers_addrs)) {
 
2488
    m_valid = false;
 
2489
  }
 
2490
  // search_list is optional
 
2491
  if (m_ele->search_list && !INKDomainListIsValid(m_ele->search_list)) {
 
2492
    m_valid = false;
 
2493
  }
 
2494
 
 
2495
  if (!m_valid)
 
2496
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
2497
 
 
2498
  return m_valid;
 
2499
}
 
2500
 
 
2501
INKCfgEle *
 
2502
SplitDnsObj::getCfgEleCopy()
 
2503
{
 
2504
  return (INKCfgEle *) copy_split_dns_ele(m_ele);
 
2505
}
 
2506
 
 
2507
//--------------------------------------------------------------------------
 
2508
// StorageObj
 
2509
//--------------------------------------------------------------------------
 
2510
StorageObj::StorageObj(INKStorageEle * ele)
 
2511
{
 
2512
  m_ele = ele;
 
2513
  m_valid = true;
 
2514
  m_valid = isValid();          // now validate
 
2515
}
 
2516
 
 
2517
// must have at least 1 token (token-name = pathname, token-value = size (if any) )
 
2518
StorageObj::StorageObj(TokenList * tokens)
 
2519
{
 
2520
  Token *tok;
 
2521
 
 
2522
  m_ele = INKStorageEleCreate();
 
2523
  m_ele->cfg_ele.error = INK_ERR_OKAY;
 
2524
  m_valid = true;
 
2525
 
 
2526
  if (!tokens || (tokens->length > 6)) {
 
2527
    goto FORMAT_ERR;
 
2528
  }
 
2529
 
 
2530
  m_ele->cfg_ele.type = get_rule_type(tokens, INK_FNAME_STORAGE);
 
2531
  if (m_ele->cfg_ele.type == INK_TYPE_UNDEFINED) {
 
2532
    goto FORMAT_ERR;
 
2533
  }
 
2534
  // check first token; must exist
 
2535
  tok = tokens->first();
 
2536
  if (!tok->name) {
 
2537
    goto FORMAT_ERR;            // no pathname specified
 
2538
  } else {
 
2539
    m_ele->pathname = xstrdup(tok->name);
 
2540
  }
 
2541
 
 
2542
  // check if size is specified
 
2543
  if (tok->value)               // size is specified in second token
 
2544
    m_ele->size = ink_atoi(tok->value);
 
2545
 
 
2546
  return;
 
2547
 
 
2548
FORMAT_ERR:
 
2549
  m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
2550
  m_valid = false;
 
2551
}
 
2552
 
 
2553
StorageObj::~StorageObj()
 
2554
{
 
2555
  INKStorageEleDestroy(m_ele);
 
2556
}
 
2557
 
 
2558
char *
 
2559
StorageObj::formatEleToRule()
 
2560
{
 
2561
  if (!isValid()) {
 
2562
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
2563
    return NULL;
 
2564
  }
 
2565
 
 
2566
  char buf[MAX_RULE_SIZE];
 
2567
  memset(buf, 0, MAX_RULE_SIZE);
 
2568
 
 
2569
  if (m_ele->size < 0) {        // if size < 0, then raw partition
 
2570
    snprintf(buf, sizeof(buf), "%s", m_ele->pathname);
 
2571
  } else {
 
2572
    snprintf(buf, sizeof(buf), "%s %d", m_ele->pathname, m_ele->size);
 
2573
  }
 
2574
 
 
2575
  return xstrdup(buf);
 
2576
}
 
2577
 
 
2578
bool StorageObj::isValid()
 
2579
{
 
2580
  if (m_ele->cfg_ele.error != INK_ERR_OKAY) {
 
2581
    m_valid = false;
 
2582
  }
 
2583
 
 
2584
  if (!(m_ele->pathname))
 
2585
    m_valid = false;
 
2586
 
 
2587
  if (!m_valid)
 
2588
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
2589
 
 
2590
  return m_valid;
 
2591
}
 
2592
 
 
2593
INKCfgEle *
 
2594
StorageObj::getCfgEleCopy()
 
2595
{
 
2596
  return (INKCfgEle *) copy_storage_ele(m_ele);
 
2597
}
 
2598
 
 
2599
//--------------------------------------------------------------------------
 
2600
// UpdateObj
 
2601
//--------------------------------------------------------------------------
 
2602
UpdateObj::UpdateObj(INKUpdateEle * ele)
 
2603
{
 
2604
  m_ele = ele;
 
2605
  m_valid = true;
 
2606
  m_valid = isValid();
 
2607
}
 
2608
 
 
2609
UpdateObj::UpdateObj(TokenList * tokens)
 
2610
{
 
2611
  Token *token;
 
2612
 
 
2613
  m_ele = INKUpdateEleCreate();
 
2614
  m_ele->cfg_ele.error = INK_ERR_OKAY;
 
2615
  m_valid = true;
 
2616
 
 
2617
  if (!tokens || tokens->length < 5) {
 
2618
    goto FORMAT_ERR;
 
2619
  }
 
2620
 
 
2621
  m_ele->cfg_ele.type = get_rule_type(tokens, INK_FNAME_UPDATE_URL);
 
2622
  if (m_ele->cfg_ele.type == INK_TYPE_UNDEFINED) {
 
2623
    goto FORMAT_ERR;
 
2624
  }
 
2625
  // URL
 
2626
  token = tokens->first();
 
2627
  if (strcmp(token->name, "") == 0) {
 
2628
    goto FORMAT_ERR;
 
2629
  }
 
2630
  m_ele->url = xstrdup(token->name);
 
2631
 
 
2632
  // Request_headers
 
2633
  token = tokens->next(token);
 
2634
  m_ele->headers = string_to_string_list(token->name, ";");
 
2635
 
 
2636
  // Offset_hour
 
2637
  token = tokens->next(token);
 
2638
  if (strcmp(token->name, "") == 0) {
 
2639
    goto FORMAT_ERR;
 
2640
  }
 
2641
  m_ele->offset_hour = ink_atoi(token->name);
 
2642
 
 
2643
  // Interval
 
2644
  token = tokens->next(token);
 
2645
  if (strcmp(token->name, "") == 0) {
 
2646
    goto FORMAT_ERR;
 
2647
  }
 
2648
  m_ele->interval = ink_atoi(token->name);
 
2649
 
 
2650
  // Recursion_depth
 
2651
  token = tokens->next(token);
 
2652
  if (strcmp(token->name, "") == 0) {
 
2653
    goto FORMAT_ERR;
 
2654
  }
 
2655
  m_ele->recursion_depth = ink_atoi(token->name);
 
2656
  return;
 
2657
 
 
2658
FORMAT_ERR:
 
2659
  m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
2660
  m_valid = false;
 
2661
}
 
2662
 
 
2663
UpdateObj::~UpdateObj()
 
2664
{
 
2665
  INKUpdateEleDestroy(m_ele);
 
2666
}
 
2667
 
 
2668
char *
 
2669
UpdateObj::formatEleToRule()
 
2670
{
 
2671
  if (!isValid()) {
 
2672
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
2673
    return NULL;
 
2674
  }
 
2675
 
 
2676
  char *list_str;
 
2677
  char buf[MAX_RULE_SIZE];
 
2678
  memset(buf, 0, MAX_RULE_SIZE);
 
2679
 
 
2680
  list_str = string_list_to_string(m_ele->headers, ";");
 
2681
  if (list_str) {
 
2682
    snprintf(buf, sizeof(buf), "%s\\%s\\%d\\%d\\%d\\",
 
2683
             m_ele->url, list_str, m_ele->offset_hour, m_ele->interval, m_ele->recursion_depth);
 
2684
    xfree(list_str);
 
2685
  } else {
 
2686
    snprintf(buf, sizeof(buf), "%s\\\\%d\\%d\\%d\\",
 
2687
             m_ele->url, m_ele->offset_hour, m_ele->interval, m_ele->recursion_depth);
 
2688
  }
 
2689
 
 
2690
  return xstrdup(buf);
 
2691
}
 
2692
 
 
2693
bool UpdateObj::isValid()
 
2694
{
 
2695
  if (m_ele->cfg_ele.error != INK_ERR_OKAY) {
 
2696
    m_valid = false;
 
2697
  }
 
2698
  // check url
 
2699
  if (!m_ele->url || strcmp(m_ele->url, "") == 0 ||
 
2700
      strstr(m_ele->url, "\\") ||
 
2701
      (!strstr(m_ele->url, "http") && !strstr(m_ele->url, "rtsp"))) {
 
2702
    m_valid = false;
 
2703
  }
 
2704
  // bug 49322: check that there are no "\" in the url or headers
 
2705
  char *
 
2706
    list_str = string_list_to_string(m_ele->headers, ";");
 
2707
  if (list_str) {
 
2708
    if (strstr(list_str, "\\"))
 
2709
      m_valid = false;
 
2710
    xfree(list_str);
 
2711
  }
 
2712
  // offset hour range is 00-23
 
2713
  if (m_ele->offset_hour < 0 || m_ele->offset_hour > 23)
 
2714
    m_valid = false;
 
2715
 
 
2716
  if (m_ele->interval < 0)
 
2717
    m_valid = false;
 
2718
 
 
2719
  // optional - default is 0
 
2720
  if (m_ele->recursion_depth < 0) {
 
2721
    m_valid = false;
 
2722
  }
 
2723
  // recursion depth can only be specified for http
 
2724
  if (m_ele->recursion_depth > 0) {
 
2725
    if (!strstr(m_ele->url, "http"))
 
2726
      m_valid = false;
 
2727
  }
 
2728
 
 
2729
  if (!m_valid)
 
2730
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
2731
 
 
2732
  return m_valid;
 
2733
}
 
2734
 
 
2735
INKCfgEle *
 
2736
UpdateObj::getCfgEleCopy()
 
2737
{
 
2738
  return (INKCfgEle *) copy_update_ele(m_ele);
 
2739
}
 
2740
 
 
2741
//--------------------------------------------------------------------------
 
2742
// VirtIpAddrObj
 
2743
//--------------------------------------------------------------------------
 
2744
VirtIpAddrObj::VirtIpAddrObj(INKVirtIpAddrEle * ele)
 
2745
{
 
2746
  m_ele = ele;
 
2747
  m_valid = true;
 
2748
  m_valid = isValid();
 
2749
}
 
2750
 
 
2751
VirtIpAddrObj::VirtIpAddrObj(TokenList * tokens)
 
2752
{
 
2753
  Token *tok;
 
2754
 
 
2755
  m_ele = INKVirtIpAddrEleCreate();
 
2756
  m_ele->cfg_ele.error = INK_ERR_OKAY;
 
2757
  m_valid = true;
 
2758
 
 
2759
  if (!tokens || (tokens->length != 3)) {
 
2760
    goto FORMAT_ERR;
 
2761
  }
 
2762
 
 
2763
  m_ele->cfg_ele.type = get_rule_type(tokens, INK_FNAME_VADDRS);
 
2764
  if (m_ele->cfg_ele.type == INK_TYPE_UNDEFINED) {
 
2765
    goto FORMAT_ERR;
 
2766
  }
 
2767
  // IP Address
 
2768
  tok = tokens->first();
 
2769
  if (tok->value != NULL) {
 
2770
    goto FORMAT_ERR;
 
2771
  }
 
2772
  m_ele->ip_addr = string_to_ip_addr(tok->name);
 
2773
 
 
2774
  // Device
 
2775
  tok = tokens->next(tok);
 
2776
  if (tok->value != NULL) {
 
2777
    goto FORMAT_ERR;
 
2778
  }
 
2779
  m_ele->intr = xstrdup(tok->name);
 
2780
 
 
2781
  // Subinterface
 
2782
  tok = tokens->next(tok);
 
2783
  if (tok->value != NULL) {
 
2784
    goto FORMAT_ERR;
 
2785
  }
 
2786
  m_ele->sub_intr = ink_atoi(tok->name);        // ERROR: can't convert?
 
2787
 
 
2788
  return;
 
2789
 
 
2790
FORMAT_ERR:
 
2791
  m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
2792
  m_valid = false;
 
2793
}
 
2794
 
 
2795
VirtIpAddrObj::~VirtIpAddrObj()
 
2796
{
 
2797
  INKVirtIpAddrEleDestroy(m_ele);
 
2798
}
 
2799
 
 
2800
char *
 
2801
VirtIpAddrObj::formatEleToRule()
 
2802
{
 
2803
  if (!isValid()) {
 
2804
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
2805
    return NULL;
 
2806
  }
 
2807
 
 
2808
  char *ip_str;
 
2809
  char buf[MAX_RULE_SIZE];
 
2810
  memset(buf, 0, MAX_RULE_SIZE);
 
2811
 
 
2812
  ip_str = ip_addr_to_string(m_ele->ip_addr);
 
2813
  snprintf(buf, sizeof(buf), "%s %s %d", ip_str, m_ele->intr, m_ele->sub_intr);
 
2814
  if (ip_str)
 
2815
    xfree(ip_str);
 
2816
 
 
2817
  return xstrdup(buf);
 
2818
}
 
2819
 
 
2820
bool VirtIpAddrObj::isValid()
 
2821
{
 
2822
  if (m_ele->cfg_ele.error != INK_ERR_OKAY) {
 
2823
    m_valid = false;
 
2824
  }
 
2825
 
 
2826
  if (!ccu_checkIpAddr(m_ele->ip_addr)) {
 
2827
    m_valid = false;
 
2828
  }
 
2829
 
 
2830
  if (!m_ele->intr) {
 
2831
    m_valid = false;
 
2832
  }
 
2833
 
 
2834
  if ((m_ele->sub_intr < 1) || (m_ele->sub_intr > 255)) {
 
2835
    m_valid = false;
 
2836
  }
 
2837
 
 
2838
  if (!m_valid)
 
2839
    m_ele->cfg_ele.error = INK_ERR_INVALID_CONFIG_RULE;
 
2840
 
 
2841
  return m_valid;
 
2842
}
 
2843
 
 
2844
INKCfgEle *
 
2845
VirtIpAddrObj::getCfgEleCopy()
 
2846
{
 
2847
  return (INKCfgEle *) copy_virt_ip_addr_ele(m_ele);
 
2848
}
 
2849
 
 
2850
 
 
2851
/*****************************************************************
 
2852
 * CfgContext
 
2853
 *****************************************************************/
 
2854
CfgContext::CfgContext(INKFileNameT filename)
 
2855
{
 
2856
  m_file = filename;
 
2857
  m_ver = -1;
 
2858
}
 
2859
 
 
2860
CfgContext::~CfgContext()
 
2861
{
 
2862
  CfgEleObj *ele;
 
2863
  while ((ele = m_eles.dequeue())) {
 
2864
    delete ele;
 
2865
  }
 
2866
}
 
2867
 
 
2868
INKError CfgContext::addEle(CfgEleObj * ele)
 
2869
{
 
2870
  ink_assert(ele != NULL);
 
2871
  m_eles.enqueue(ele);          // enqueue CfgEleObj at end of Queue
 
2872
  return INK_ERR_OKAY;
 
2873
}
 
2874
 
 
2875
INKError CfgContext::removeEle(CfgEleObj * ele)
 
2876
{
 
2877
  ink_assert(ele != NULL);
 
2878
  m_eles.remove(ele);
 
2879
  delete
 
2880
    ele;
 
2881
 
 
2882
  return INK_ERR_OKAY;
 
2883
}
 
2884
 
 
2885
INKError CfgContext::insertEle(CfgEleObj * ele, CfgEleObj * after_ele)
 
2886
{
 
2887
  ink_assert(ele != NULL && after_ele != NULL);
 
2888
  m_eles.insert(ele, after_ele);
 
2889
 
 
2890
  return INK_ERR_OKAY;
 
2891
}
 
2892
 
 
2893
// insert Ele at front of the Queue
 
2894
INKError CfgContext::pushEle(CfgEleObj * ele)
 
2895
{
 
2896
  ink_assert(ele != NULL);
 
2897
  m_eles.push(ele);
 
2898
 
 
2899
  return INK_ERR_OKAY;
 
2900
}