You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficserver.apache.org by zw...@apache.org on 2013/11/21 19:42:26 UTC
[18/44] TS-2349: Move traffic_shell to the cmd subdirectory
http://git-wip-us.apache.org/repos/asf/trafficserver/blob/775ad1dc/cmd/traffic_shell/ConfigCmd.cc
----------------------------------------------------------------------
diff --git a/cmd/traffic_shell/ConfigCmd.cc b/cmd/traffic_shell/ConfigCmd.cc
new file mode 100644
index 0000000..a40da20
--- /dev/null
+++ b/cmd/traffic_shell/ConfigCmd.cc
@@ -0,0 +1,4626 @@
+/** @file
+
+ This file contains the CLI's "config" command implementation.
+
+ @section license License
+
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements. See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership. The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+ @section description createArgument("timezone",1,CLI_ARGV_OPTION_INT_VALUE,
+ (char*)NULL, CMD_CONFIG_TIMEZONE, "Time Zone",
+ (char*)NULL);
+ */
+
+
+#include "libts.h"
+#include "I_Layout.h"
+#include "mgmtapi.h"
+#include "ShowCmd.h"
+#include "ConfigCmd.h"
+#include "createArgument.h"
+#include "CliMgmtUtils.h"
+#include "CliDisplay.h"
+// TODO: Remove all those system defines
+// and protecect them via #ifdef HAVE_FOO_H
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <termios.h>
+#include <stdarg.h>
+#include <sys/ioctl.h>
+#include <time.h>
+#include <sys/time.h>
+#include <string.h>
+#include <unistd.h>
+#include <limits.h>
+#include <sys/wait.h>
+#include <errno.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+
+bool enable_restricted_commands = false;
+
+static int find_value(const char *pathname, const char *key, char *value, int value_len, const char *delim, int no);
+
+int
+u_getch(void)
+{
+ static signed int returned = (-1), fd;
+ static struct termios new_io_settings, old_io_settings;
+ fd = fileno(stdin);
+ tcgetattr(fd, &old_io_settings);
+ new_io_settings = old_io_settings;
+ new_io_settings.c_lflag &= ~(ICANON | ECHO);
+ tcsetattr(fd, TCSANOW, &new_io_settings);
+ returned = getchar();
+ tcsetattr(fd, TCSANOW, &old_io_settings);
+ return returned;
+}
+
+////////////////////////////////////////////////////////////////
+// Cmd_Enable
+//
+// This is the callback
+// function for the "enable" command.
+// TODO: This currently doesn't do anything, these commands are
+// always available.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_Enable(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+ cli_parsedArgInfo *argtable, *infoPtr;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ argtable = cmdCallbackInfo->parsedArgTable;
+ infoPtr = argtable;
+
+ /* Add "enable status" to check the status of enable/disable */
+ if (argc == 2) {
+ switch (infoPtr->parsed_args) {
+ case CMD_ENABLE_STATUS:
+ if (enable_restricted_commands == true) {
+ Cli_Printf("on\n");
+ return CMD_OK;
+ } else {
+ Cli_Printf("off\n");
+ return CMD_ERROR;
+ }
+ default:
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+ }
+ }
+
+ if (enable_restricted_commands == true) {
+ Cli_Printf("Already Enabled\n");
+ return CMD_OK;
+ }
+
+ // TODO: replace this assert with appropriate authentication
+ ink_release_assert(enable_restricted_commands);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_Enable
+//
+// Register "enable" arguments with the Tcl interpreter.
+//
+int
+CmdArgs_Enable()
+{
+
+ createArgument("status", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_ENABLE_STATUS, "Check Enable Status", (char *) NULL);
+ return CLI_OK;
+}
+
+////////////////////////////////////////////////////////////////
+// Cmd_Disable
+//
+// This is the callback
+// function for the "disable" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_Disable(ClientData /* clientData ATS_UNUSED */, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (getuid() == 0) {
+ Cli_Printf("root user cannot \"disable\"\n");
+ return 0;
+ }
+
+ enable_restricted_commands = false;
+ return 0;
+}
+
+
+
+////////////////////////////////////////////////////////////////
+// Cmd_Config
+//
+// This is the callback function for the "config" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_Config(ClientData /* clientData ATS_UNUSED */, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ char *cmdinfo, *temp;
+ int i = 0;
+
+ Cli_Debug("Cmd_Config\n");
+ Tcl_Eval(interp, "info commands config* ");
+
+ size_t cmdinfo_len = strlen(Tcl_GetStringResult(interp)) + 2;
+ cmdinfo = (char *)alloca(sizeof(char) * cmdinfo_len);
+ ink_strlcpy(cmdinfo, Tcl_GetStringResult(interp), cmdinfo_len);
+ size_t temp_len = strlen(cmdinfo) + 20;
+ temp = (char *)alloca(sizeof(char) * temp_len);
+ ink_strlcpy(temp, "lsort \"", temp_len);
+ ink_strlcat(temp, cmdinfo, temp_len);
+ ink_strlcat(temp, "\"", temp_len);
+
+ Tcl_Eval(interp, temp);
+ ink_strlcpy(cmdinfo, Tcl_GetStringResult(interp), cmdinfo_len);
+ i = i + strlen("config ");
+ while (cmdinfo[i] != 0) {
+ if (cmdinfo[i] == ' ') {
+ cmdinfo[i] = '\n';
+ }
+ i++;
+ }
+ cmdinfo[i] = '\n';
+ i++;
+ cmdinfo[i] = 0;
+ Cli_Printf("Following are the available config commands\n");
+ Cli_Printf(cmdinfo + strlen("config "));
+
+ return CLI_OK;
+
+}
+
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_Config
+//
+// Register "config" command arguments with the Tcl interpreter.
+//
+int
+CmdArgs_Config()
+{
+ Cli_Debug("CmdArgs_Config\n");
+
+ return CLI_OK;
+}
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigGet
+//
+// This is the callback function for the "config:get" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigGet(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (cliCheckIfEnabled("config:get") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+
+ Cli_Debug("Cmd_ConfigGet argc %d\n", argc);
+
+ if (argc == 2) {
+ return (ConfigGet(argv[1]));
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigSet
+//
+// This is the callback function for the "config:set" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigSet(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (cliCheckIfEnabled("config:set") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+
+ Cli_Debug("Cmd_ConfigSet argc %d\n", argc);
+
+ if (argc == 3) {
+ return (ConfigSet(argv[1], argv[2]));
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigName
+//
+// This is the callback function for the "config:name" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigName(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (cliCheckIfEnabled("config:name") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+
+ Cli_Debug("Cmd_ConfigName argc %d\n", argc);
+
+ return (ConfigName(argv[1]));
+
+ // coverity[unreachable]
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigStart
+//
+// This is the callback function for the "config:start" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigStart(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (cliCheckIfEnabled("config:start") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+
+ Cli_Debug("Cmd_ConfigStart argc %d\n", argc);
+
+ if (argc == 1) {
+ return (ConfigStart());
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigStop
+//
+// This is the callback function for the "config:stop" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigStop(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+ if (cliCheckIfEnabled("config:stop") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ Cli_Debug("Cmd_ConfigStop argc %d\n", argc);
+
+ if (argc == 1) {
+ return (ConfigStop());
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigHardRestart
+//
+// This is the callback function for the "config:hard-restart" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigHardRestart(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+ if (cliCheckIfEnabled("config:hard-restart") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ Cli_Debug("Cmd_ConfigHardRestart argc %d\n", argc);
+
+ if (argc == 1) {
+ return (TSHardRestart());
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigRestart
+//
+// This is the callback function for the "config:restart" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigRestart(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+ if (cliCheckIfEnabled("config:restart") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+ cli_parsedArgInfo *argtable;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ argtable = cmdCallbackInfo->parsedArgTable;
+ Cli_Debug("Cmd_ConfigRestart argc %d\n", argc);
+
+ if (argc == 1) {
+ return (TSRestart(false));
+ } else if (argc == 2) {
+ if (argtable[0].parsed_args == CMD_CONFIG_RESTART_CLUSTER) {
+ return (TSRestart(true));
+ }
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_ConfigRestart
+//
+// Register "config:restart" arguments with the Tcl interpreter.
+//
+int
+CmdArgs_ConfigRestart()
+{
+ createArgument("cluster", 1, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_RESTART_CLUSTER, "Restart the entire cluster", (char *) NULL);
+
+ return 0;
+}
+
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigParents
+//
+// This is the callback function for the "config:parents" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigParents(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (cliCheckIfEnabled("config:parents") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+ Cli_Debug("Cmd_ConfigParents argc %d\n", argc);
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+ cli_parsedArgInfo *argtable, *infoPtr;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ argtable = cmdCallbackInfo->parsedArgTable;
+ infoPtr = argtable;
+
+ if (argc == 1) {
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+ }
+
+ if (argtable->parsed_args != CLI_PARSED_ARGV_END) {
+ switch (infoPtr->parsed_args) {
+ case CMD_CONFIG_PARENTS_STATUS:
+ return (Cli_RecordOnOff_Action((argc == 3),
+ "proxy.config.http.parent_proxy_routing_enable", argtable->arg_string));
+
+ case CMD_CONFIG_PARENTS_CACHE:
+ return (Cli_RecordString_Action((argc == 3), "proxy.config.http.parent_proxies", argtable->arg_string));
+
+ case CMD_CONFIG_PARENTS_CONFIG_FILE:
+ return (Cli_ConfigFileURL_Action(TS_FNAME_PARENT_PROXY, "parent.config", argtable->arg_string));
+ }
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_ConfigParents
+//
+// Register "config:parents" arguments with the Tcl interpreter.
+//
+int
+CmdArgs_ConfigParents()
+{
+
+ createArgument("status", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_PARENTS_STATUS, "Parenting <on|off>", (char *) NULL);
+ createArgument("name", CLI_ARGV_NO_POS, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_PARENTS_CACHE, "Specify cache parent", (char *) NULL);
+ createArgument("rules", CLI_ARGV_NO_POS, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_PARENTS_CONFIG_FILE, "Specify config file", (char *) NULL);
+ return CLI_OK;
+}
+
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigRemap
+//
+// This is the callback function for the "config:remap" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigRemap(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (cliCheckIfEnabled("config:remap") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ Cli_Debug("Cmd_ConfigRemap argc %d\n", argc);
+
+ if (argc == 2) {
+ return (ConfigRemap(argv[1]));
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigPorts
+//
+// This is the callback function for the "config:ports" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigPorts(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (cliCheckIfEnabled("config:ports") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+
+ Cli_Debug("Cmd_ConfigPorts argc %d\n", argc);
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+ cli_parsedArgInfo *argtable;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ argtable = cmdCallbackInfo->parsedArgTable;
+
+ Cli_Debug("Cmd_ConfigPorts argc %d\n", argc);
+
+ if (argtable->parsed_args != CLI_PARSED_ARGV_END) {
+
+ if (argc == 2) { // get
+ return (ConfigPortsGet(argtable[0].parsed_args));
+ } else { // set
+ switch (argtable->parsed_args) {
+ case CMD_CONFIG_PORTS_CONNECT:
+ return (ConfigPortsSet(argtable[0].parsed_args, argtable[0].data));
+ break;
+ case CMD_CONFIG_PORTS_HTTP_SERVER:
+ case CMD_CONFIG_PORTS_CLUSTER:
+ case CMD_CONFIG_PORTS_CLUSTER_RS:
+ case CMD_CONFIG_PORTS_CLUSTER_MC:
+ case CMD_CONFIG_PORTS_SOCKS_SERVER:
+ case CMD_CONFIG_PORTS_ICP:
+ return (ConfigPortsSet(argtable[0].parsed_args, &argtable[0].arg_int));
+ }
+ }
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX,
+ "\n\nconfig:ports <http-server | http-other | webui | cluster-rs | cluster-mc | \n ssl | \n socks-server | icp > \n <port | ports list>\n");
+ return CMD_ERROR;
+
+}
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_ConfigPorts
+//
+// Register "config:ports" arguments with the Tcl interpreter.
+//
+int
+CmdArgs_ConfigPorts()
+{
+ createArgument("http-server", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_PORTS_HTTP_SERVER, "Set Ports for http-server", (char *) NULL);
+ createArgument("cluster", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_PORTS_CLUSTER, "Set Ports for cluster", (char *) NULL);
+ createArgument("cluster-rs", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_PORTS_CLUSTER_RS, "Set Ports for cluster-rs", (char *) NULL);
+ createArgument("cluster-mc", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_PORTS_CLUSTER_MC, "Set Ports for cluster-mc", (char *) NULL);
+ createArgument("connect", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_PORTS_CONNECT, "Set Ports for allowed CONNECT", (char *) NULL);
+ createArgument("socks-server", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_PORTS_SOCKS_SERVER, "Set Ports for socks-server", (char *) NULL);
+ return 0;
+}
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigClock
+//
+// This is the callback function for the "config:clock" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigClock(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ int setvar = 0;
+
+ if (cliCheckIfEnabled("config:clock") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+ Cli_Debug("Cmd_ConfigClock argc %d\n", argc);
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+ cli_parsedArgInfo *argtable;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ argtable = cmdCallbackInfo->parsedArgTable;
+
+ Cli_PrintArg(0, argtable);
+ Cli_PrintArg(1, argtable);
+
+ if (argtable[0].parsed_args != CLI_PARSED_ARGV_END) {
+ switch (argtable[0].parsed_args) {
+ case CMD_CONFIG_DATE:
+ return (ConfigDate(argtable->arg_string));
+ case CMD_CONFIG_TIME:
+ return (ConfigTime(argtable->arg_string));
+ case CMD_CONFIG_TIMEZONE:
+ if (argc == 3) {
+ setvar = 1;
+ }
+ if (argtable[1].parsed_args == CMD_CONFIG_TIMEZONE_LIST) {
+ return (ConfigTimezoneList());
+ } else {
+ return (ConfigTimezone(argtable->arg_int, setvar));
+ }
+ }
+ }
+
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_ConfigClock
+//
+// Register "config:clock" arguments with the Tcl interpreter.
+//
+int
+CmdArgs_ConfigClock()
+{
+ createArgument("date", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_DATE, "System Date <mm/dd/yyyy>", (char *) NULL);
+
+ createArgument("time", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_TIME, "System Time <hh:mm:ss>", (char *) NULL);
+
+ createArgument("timezone", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_TIMEZONE, "Time Zone", (char *) NULL);
+
+ createArgument("list", CMD_CONFIG_TIMEZONE, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_TIMEZONE_LIST, "Display Time Zone List", (char *) NULL);
+
+ return 0;
+}
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigSecurity
+//
+// This is the callback function for the "config:security" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigSecurity(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (cliCheckIfEnabled("config:security") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+ Cli_Debug("Cmd_ConfigSecurity argc %d\n", argc);
+
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+ cli_parsedArgInfo *argtable;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ argtable = cmdCallbackInfo->parsedArgTable;
+
+ if (argtable[0].parsed_args != CLI_PARSED_ARGV_END) {
+ switch (argtable[0].parsed_args) {
+ case CMD_CONFIG_SECURITY_IP:
+ return (Cli_ConfigFileURL_Action(TS_FNAME_IP_ALLOW, "ip_allow.config", argtable->arg_string));
+
+ case CMD_CONFIG_SECURITY_PASSWORD:
+ return (ConfigSecurityPasswd());
+ }
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_ConfigSecurity
+//
+// Register "config:security" arguments with the Tcl interpreter.
+//
+int
+CmdArgs_ConfigSecurity()
+{
+ createArgument("ip-allow", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_SECURITY_IP, "Clients allowed to connect to proxy <url>", (char *) NULL);
+ createArgument("password", 1, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_SECURITY_PASSWORD, "Change Admin Password", (char *) NULL);
+ return 0;
+}
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigHttp
+//
+// This is the callback function for the "config:http" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigHttp(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ int setvar = 0;
+ if (cliCheckIfEnabled("config:http") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+
+ Cli_Debug("Cmd_ConfigHttp argc %d\n", argc);
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+ cli_parsedArgInfo *argtable;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ argtable = cmdCallbackInfo->parsedArgTable;
+
+ if (argc == 3) {
+ setvar = 1;
+ }
+
+ if (argc > 3) {
+ Cli_Error("Too many arguments\n");
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+ }
+
+ Cli_PrintArg(0, argtable);
+ Cli_PrintArg(1, argtable);
+
+ int action = (argc == 3) ? RECORD_SET : RECORD_GET;
+
+ if (argtable->parsed_args != CLI_PARSED_ARGV_END) {
+ switch (argtable->parsed_args) {
+ case CMD_CONFIG_HTTP_STATUS:
+ return (Cli_RecordOnOff_Action(action, "proxy.config.http.cache.http", argtable->arg_string));
+
+ case CMD_CONFIG_HTTP_KEEP_ALIVE_TIMEOUT_IN:
+ return (Cli_RecordInt_Action(action, "proxy.config.http.keep_alive_no_activity_timeout_in", argtable->arg_int));
+
+ case CMD_CONFIG_HTTP_KEEP_ALIVE_TIMEOUT_OUT:
+ return (Cli_RecordInt_Action(action, "proxy.config.http.keep_alive_no_activity_timeout_out", argtable->arg_int));
+
+ case CMD_CONFIG_HTTP_INACTIVE_TIMEOUT_IN:
+ return (Cli_RecordInt_Action(action, "proxy.config.http.transaction_no_activity_timeout_in", argtable->arg_int));
+
+ case CMD_CONFIG_HTTP_INACTIVE_TIMEOUT_OUT:
+ return (Cli_RecordInt_Action(action, "proxy.config.http.transaction_no_activity_timeout_out", argtable->arg_int));
+
+ case CMD_CONFIG_HTTP_ACTIVE_TIMEOUT_IN:
+ return (Cli_RecordInt_Action(action, "proxy.config.http.transaction_active_timeout_in", argtable->arg_int));
+
+ case CMD_CONFIG_HTTP_ACTIVE_TIMEOUT_OUT:
+ return (Cli_RecordInt_Action(action, "proxy.config.http.transaction_active_timeout_out", argtable->arg_int));
+
+ case CMD_CONFIG_HTTP_REMOVE_FROM:
+ return (Cli_RecordOnOff_Action(action, "proxy.config.http.anonymize_remove_from", argtable->arg_string));
+
+ case CMD_CONFIG_HTTP_REMOVE_REFERER:
+ return (Cli_RecordOnOff_Action(action, "proxy.config.http.anonymize_remove_referer", argtable->arg_string));
+
+ case CMD_CONFIG_HTTP_REMOVE_USER:
+ return (Cli_RecordOnOff_Action(action, "proxy.config.http.anonymize_remove_user_agent", argtable->arg_string));
+
+ case CMD_CONFIG_HTTP_REMOVE_COOKIE:
+ return (Cli_RecordOnOff_Action(action, "proxy.config.http.anonymize_remove_cookie", argtable->arg_string));
+
+ case CMD_CONFIG_HTTP_REMOVE_HEADER:
+ return (Cli_RecordString_Action(action, "proxy.config.http.anonymize_other_header_list", argtable->arg_string));
+
+ case CMD_CONFIG_HTTP_GLOBAL_USER_AGENT:
+ return (Cli_RecordString_Action(action, "proxy.config.http.global_user_agent_header", argtable->arg_string));
+
+ case CMD_CONFIG_HTTP_INSERT_IP:
+ return (Cli_RecordOnOff_Action(action, "proxy.config.http.anonymize_insert_client_ip", argtable->arg_string));
+
+ case CMD_CONFIG_HTTP_REMOVE_IP:
+ return (Cli_RecordOnOff_Action(action, "proxy.config.http.anonymize_remove_client_ip", argtable->arg_string));
+
+ case CMD_CONFIG_HTTP_PROXY:
+ return (ConfigHttpProxy(argtable[1].parsed_args, setvar));
+ }
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_ConfigHttp
+//
+// Register "config:http" arguments with the Tcl interpreter.
+//
+int
+CmdArgs_ConfigHttp()
+{
+ createArgument("status", CLI_ARGV_NO_POS, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_HTTP_STATUS, "HTTP proxying <on | off>", (char *) NULL);
+
+ createArgument("keep-alive-timeout-in", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_HTTP_KEEP_ALIVE_TIMEOUT_IN, "Keep alive timeout inbound <seconds>",
+ (char *) NULL);
+ createArgument("keep-alive-timeout-out", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_HTTP_KEEP_ALIVE_TIMEOUT_OUT, "Keep alive timeout outbound <seconds>",
+ (char *) NULL);
+ createArgument("inactive-timeout-in", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_HTTP_INACTIVE_TIMEOUT_IN, "Inactive timeout inbound <seconds>",
+ (char *) NULL);
+ createArgument("inactive-timeout-out", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_HTTP_INACTIVE_TIMEOUT_OUT, "Inactive timeout outbound <seconds>",
+ (char *) NULL);
+ createArgument("active-timeout-in", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_HTTP_ACTIVE_TIMEOUT_IN, "Active timeout inbound <seconds>", (char *) NULL);
+ createArgument("active-timeout-out", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_HTTP_ACTIVE_TIMEOUT_OUT, "Active timeout outbound <seconds>", (char *) NULL);
+
+ createArgument("remove-from", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_HTTP_REMOVE_FROM, "Remove \"From:\" header <on|off>", (char *) NULL);
+ createArgument("remove-referer", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_HTTP_REMOVE_REFERER, "Remove \"Referer:\" header <on|off>", (char *) NULL);
+ createArgument("remove-user", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_HTTP_REMOVE_USER, "Remove \"User:\" header <on|off>", (char *) NULL);
+ createArgument("remove-cookie", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_HTTP_REMOVE_COOKIE, "Remove \"Cookie:\" header <on|off>", (char *) NULL);
+ createArgument("remove-header", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_HTTP_REMOVE_HEADER, "String of headers to be removed <string>",
+ (char *) NULL);
+
+ createArgument("global-user-agent", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_HTTP_GLOBAL_USER_AGENT, "User-Agent to send to Origin <string>",
+ (char *) NULL);
+
+ createArgument("insert-ip", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_HTTP_INSERT_IP, "Insert client IP into header <on|off>", (char *) NULL);
+ createArgument("remove-ip", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_HTTP_REMOVE_IP, "Remove client IP from header <on|off>", (char *) NULL);
+ createArgument("proxy", 1, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_HTTP_PROXY, "Proxy Mode <fwd | rev | fwd-rev>", (char *) NULL);
+ createArgument("fwd", CMD_CONFIG_HTTP_PROXY, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_HTTP_FWD, "Specify proxy mode to be forward", (char *) NULL);
+ createArgument("rev", CMD_CONFIG_HTTP_PROXY, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_HTTP_REV, "Specify proxy mode to be reverse", (char *) NULL);
+ createArgument("fwd-rev", CMD_CONFIG_HTTP_PROXY, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_HTTP_FWD_REV, "Specify proxy mode to be both", (char *) NULL);
+ return 0;
+}
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigIcp
+//
+// This is the callback function for the "config:icp" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigIcp(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (cliCheckIfEnabled("config:icp") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+ Cli_Debug("Cmd_ConfigIcp argc %d\n", argc);
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+ cli_parsedArgInfo *argtable;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ argtable = cmdCallbackInfo->parsedArgTable;
+
+ int action = (argc == 3) ? RECORD_SET : RECORD_GET;
+
+ if (argtable->parsed_args != CLI_PARSED_ARGV_END) {
+ switch (argtable->parsed_args) {
+ case CMD_CONFIG_ICP_MODE:
+ return (ConfigIcpMode(argtable[1].parsed_args, action));
+
+ case CMD_CONFIG_ICP_PORT:
+ return (Cli_RecordInt_Action(action, "proxy.config.icp.icp_port", argtable->arg_int));
+
+ case CMD_CONFIG_ICP_MCAST:
+ return (Cli_RecordOnOff_Action(action, "proxy.config.icp.multicast_enabled", argtable->arg_string));
+
+ case CMD_CONFIG_ICP_QTIMEOUT:
+ return (Cli_RecordInt_Action(action, "proxy.config.icp.query_timeout", argtable->arg_int));
+
+ case CMD_CONFIG_ICP_PEERS:
+ return (Cli_ConfigFileURL_Action(TS_FNAME_ICP_PEER, "icp.config", argtable->arg_string));
+ }
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_ConfigIcp
+//
+// Register "config:Icp" arguments with the Tcl interpreter.
+//
+int
+CmdArgs_ConfigIcp()
+{
+ createArgument("mode", 1, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_ICP_MODE, "Mode <disabled | receive | send-receive>", (char *) NULL);
+
+ createArgument("receive", CMD_CONFIG_ICP_MODE, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_ICP_MODE_RECEIVE, "Specify receive mode for icp", (char *) NULL);
+
+ createArgument("send-receive", CMD_CONFIG_ICP_MODE, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_ICP_MODE_SENDRECEIVE, "Specify send & receive mode for icp", (char *) NULL);
+
+ createArgument("disabled", CMD_CONFIG_ICP_MODE, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_ICP_MODE_DISABLED, "icp mode disabled", (char *) NULL);
+
+ createArgument("port", 1, CLI_ARGV_OPTION_INT_VALUE, (char *) NULL, CMD_CONFIG_ICP_PORT, "Port <int>", (char *) NULL);
+ createArgument("multicast", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_ICP_MCAST, "Multicast <on|off>", (char *) NULL);
+ createArgument("query-timeout", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_ICP_QTIMEOUT, "Query Timeout <seconds>", (char *) NULL);
+ createArgument("peers", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_ICP_PEERS, "URL for ICP Peers config file <url>", (char *) NULL);
+ return 0;
+}
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_ConfigPortTunnles
+//
+// Register "config:PortTunnles" arguments with the Tcl interpreter.
+//
+int
+CmdArgs_ConfigPortTunnels()
+{
+
+ createArgument("server-other-ports", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_PORT_TUNNELS_SERVER_OTHER_PORTS, "Set the tunnel port number <int>",
+ (char *) NULL);
+ return 0;
+}
+
+
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigScheduledUpdate
+//
+// This is the callback function for the "config:scheduled-update" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigScheduledUpdate(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (cliCheckIfEnabled("config:scheduled-update") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+ Cli_Debug("Cmd_ConfigScheduledUpdate argc %d\n", argc);
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+ cli_parsedArgInfo *argtable;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ argtable = cmdCallbackInfo->parsedArgTable;
+
+ int action = (argc == 3) ? RECORD_SET : RECORD_GET;
+
+ if (argtable->parsed_args != CLI_PARSED_ARGV_END) {
+ switch (argtable->parsed_args) {
+ case CMD_CONFIG_SCHEDULED_UPDATE_STATUS:
+ return (Cli_RecordOnOff_Action(action, "proxy.config.update.enabled", argtable->arg_string));
+
+ case CMD_CONFIG_SCHEDULED_UPDATE_RETRY_COUNT:
+ return (Cli_RecordInt_Action(action, "proxy.config.update.retry_count", argtable->arg_int));
+
+ case CMD_CONFIG_SCHEDULED_UPDATE_RETRY_INTERVAL:
+ return (Cli_RecordInt_Action(action, "proxy.config.update.retry_interval", argtable->arg_int));
+
+ case CMD_CONFIG_SCHEDULED_UPDATE_MAX_CONCURRENT:
+ return (Cli_RecordInt_Action(action, "proxy.config.update.concurrent_updates", argtable->arg_int));
+
+ case CMD_CONFIG_SCHEDULED_UPDATE_FORCE_IMMEDIATE:
+ return (Cli_RecordOnOff_Action(action, "proxy.config.update.force", argtable->arg_string));
+
+ case CMD_CONFIG_SCHEDULED_UPDATE_RULES:
+ return (Cli_ConfigFileURL_Action(TS_FNAME_UPDATE_URL, "update.config", argtable->arg_string));
+ }
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_ConfigScheduled-Update
+//
+// Register "config:Scheduled-Update" arguments with the Tcl interpreter.
+//
+int
+CmdArgs_ConfigScheduledUpdate()
+{
+ createArgument("status", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_SCHEDULED_UPDATE_STATUS, "Set scheduled-update status <on | off>",
+ (char *) NULL);
+ createArgument("retry-count", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_SCHEDULED_UPDATE_RETRY_COUNT, "Set retry-count <int>", (char *) NULL);
+ createArgument("retry-interval", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_SCHEDULED_UPDATE_RETRY_INTERVAL, "Set retry-interval <sec>", (char *) NULL);
+ createArgument("max-concurrent", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_SCHEDULED_UPDATE_MAX_CONCURRENT, "Set maximum concurrent updates",
+ (char *) NULL);
+ createArgument("force-immediate", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_SCHEDULED_UPDATE_FORCE_IMMEDIATE, "Set force-immediate <on | off>",
+ (char *) NULL);
+ createArgument("rules", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_SCHEDULED_UPDATE_RULES, "Update update.config file from url <string>",
+ (char *) NULL);
+
+ return 0;
+}
+
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigSocks
+//
+// This is the callback function for the "config:scheduled-update" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigSocks(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (cliCheckIfEnabled("config:socks") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+ Cli_Debug("Cmd_ConfigSocks argc %d\n", argc);
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+ cli_parsedArgInfo *argtable;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ argtable = cmdCallbackInfo->parsedArgTable;
+
+ int action = (argc == 3) ? RECORD_SET : RECORD_GET;
+
+ if (argtable->parsed_args != CLI_PARSED_ARGV_END) {
+ switch (argtable->parsed_args) {
+ case CMD_CONFIG_SOCKS_STATUS:
+ return (Cli_RecordOnOff_Action(action, "proxy.config.socks.socks_needed", argtable->arg_string));
+
+ case CMD_CONFIG_SOCKS_VERSION:
+ return (Cli_RecordInt_Action(action, "proxy.config.socks.socks_version", argtable->arg_int));
+
+ case CMD_CONFIG_SOCKS_DEFAULT_SERVERS:
+ return (Cli_RecordString_Action(action, "proxy.config.socks.default_servers", argtable->arg_string));
+
+ case CMD_CONFIG_SOCKS_ACCEPT:
+ return (Cli_RecordOnOff_Action(action, "proxy.config.socks.accept_enabled", argtable->arg_string));
+
+ case CMD_CONFIG_SOCKS_ACCEPT_PORT:
+ return (Cli_RecordInt_Action(action, "proxy.config.socks.accept_port", argtable->arg_int));
+ }
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_ConfigScheduled-Update
+//
+// Register "config:Scheduled-Update" arguments with the Tcl interpreter.
+//
+int
+CmdArgs_ConfigSocks()
+{
+ createArgument("status", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_SOCKS_STATUS, "Set socks status <on | off>", (char *) NULL);
+
+ createArgument("version", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_SOCKS_VERSION, "Set version <int>", (char *) NULL);
+
+ createArgument("default-servers", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_SOCKS_DEFAULT_SERVERS, "Set default-servers <string>", (char *) NULL);
+
+ createArgument("accept", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_SOCKS_ACCEPT, "Set accept <on | off>", (char *) NULL);
+
+ createArgument("accept-port", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_SOCKS_ACCEPT_PORT, "Set server accept-port <int>", (char *) NULL);
+
+ return 0;
+}
+
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigCache
+//
+// This is the callback function for the "config:cache" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigCache(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (cliCheckIfEnabled("config:cache") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+ Cli_Debug("Cmd_ConfigCache argc %d\n", argc);
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+ cli_parsedArgInfo *argtable;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ argtable = cmdCallbackInfo->parsedArgTable;
+
+ int action = 0;
+
+ if (argtable->parsed_args != CLI_PARSED_ARGV_END) {
+ switch (argtable->parsed_args) {
+ case CMD_CONFIG_CACHE_HTTP:
+ return (Cli_RecordOnOff_Action((argc == 3), "proxy.config.http.cache.http", argtable->arg_string));
+
+ case CMD_CONFIG_CACHE_CLUSTER_BYPASS:
+ return (Cli_RecordOnOff_Action((argc == 3),
+ "proxy.config.http.cache.cluster_cache_local", argtable->arg_string));
+ case CMD_CONFIG_CACHE_IGNORE_BYPASS:
+ return (Cli_RecordOnOff_Action((argc == 3),
+ "proxy.config.http.cache.ignore_client_no_cache", argtable->arg_string));
+
+ case CMD_CONFIG_CACHE_MAX_OBJECT_SIZE:
+ return (Cli_RecordInt_Action((argc == 3), "proxy.config.cache.max_doc_size", argtable->arg_int));
+
+ case CMD_CONFIG_CACHE_MAX_ALTERNATES:
+ return (Cli_RecordInt_Action((argc == 3), "proxy.config.cache.limits.http.max_alts", argtable->arg_int));
+
+ case CMD_CONFIG_CACHE_FILE:
+ return (Cli_ConfigFileURL_Action(TS_FNAME_CACHE_OBJ, "cache.config", argtable->arg_string));
+
+ case CMD_CONFIG_CACHE_FRESHNESS:
+ if (argtable[1].parsed_args != CLI_PARSED_ARGV_END) {
+ switch (argtable[1].parsed_args) {
+ case CMD_CONFIG_CACHE_FRESHNESS_VERIFY:
+ if (argc == 4) {
+ action = RECORD_SET;
+ }
+ return (ConfigCacheFreshnessVerify(argtable[2].parsed_args, action));
+
+ case CMD_CONFIG_CACHE_FRESHNESS_MINIMUM:
+ if (argc == 4) {
+ action = RECORD_SET;
+ }
+ return (ConfigCacheFreshnessMinimum(argtable[2].parsed_args, action));
+
+ case CMD_CONFIG_CACHE_FRESHNESS_NO_EXPIRE_LIMIT:
+ if (argtable[2].parsed_args != CLI_PARSED_ARGV_END) {
+ if ((argtable[2].parsed_args ==
+ CMD_CONFIG_CACHE_FRESHNESS_NO_EXPIRE_LIMIT_GREATER_THAN) &&
+ (argtable[3].parsed_args == CMD_CONFIG_CACHE_FRESHNESS_NO_EXPIRE_LIMIT_LESS_THAN) && (argc == 7)) {
+ action = RECORD_SET;
+ } else {
+ Cli_Printf("\n config:cache freshness no-expire-limit greater-than <value> less-than<value>\n");
+ return CMD_ERROR;
+ }
+ }
+ Cli_Debug("greater than %d, less than %d \n", argtable[2].arg_int, argtable[3].arg_int);
+ return (ConfigCacheFreshnessNoExpireLimit(argtable[2].arg_int, argtable[3].arg_int, action));
+
+ }
+ }
+ Cli_Printf("\n config:cache freshness <verify | minimum | no-expire-limit> \n");
+ return CMD_ERROR;
+ case CMD_CONFIG_CACHE_DYNAMIC:
+ return (Cli_RecordOnOff_Action((argc == 3),
+ "proxy.config.http.cache.cache_urls_that_look_dynamic", argtable->arg_string));
+
+ case CMD_CONFIG_CACHE_ALTERNATES:
+ return (Cli_RecordOnOff_Action((argc == 3),
+ "proxy.config.http.cache.enable_default_vary_headers", argtable->arg_string));
+
+ case CMD_CONFIG_CACHE_VARY:
+ if (argtable[1].arg_string) {
+ action = RECORD_SET;
+ }
+ return (ConfigCacheVary(argtable[1].parsed_args, argtable[1].arg_string, action));
+
+ case CMD_CONFIG_CACHE_COOKIES:
+ if (argc == 3) {
+ action = RECORD_SET;
+ }
+ return (ConfigCacheCookies(argtable[1].parsed_args, action));
+ case CMD_CONFIG_CACHE_CLEAR:
+ return (ConfigCacheClear());
+ }
+ }
+
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_ConfigCache
+//
+// Register "config:cache" arguments with the Tcl interpreter.
+//
+int
+CmdArgs_ConfigCache()
+{
+ createArgument("http", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_CACHE_HTTP, "HTTP Protocol caching <on|off>", (char *) NULL);
+ createArgument("ignore-bypass", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_CACHE_IGNORE_BYPASS, "Ignore Bypass <on|off>", (char *) NULL);
+ createArgument("max-object-size", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_CACHE_MAX_OBJECT_SIZE, "Maximum object size <bytes>", (char *) NULL);
+ createArgument("max-alternates", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_CACHE_MAX_ALTERNATES, "Maximum alternates <int>", (char *) NULL);
+ createArgument("file", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_CACHE_FILE, "Load cache.config file from url <string>", (char *) NULL);
+ createArgument("freshness", 1, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_CACHE_FRESHNESS, "Freshness parameters <verify | minimum | no-expire-limit>",
+ (char *) NULL);
+ createArgument("verify", CMD_CONFIG_CACHE_FRESHNESS, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_CACHE_FRESHNESS_VERIFY,
+ "Freshness verify <when-expired | no-date | always | never> ", (char *) NULL);
+
+ createArgument("when-expired", CMD_CONFIG_CACHE_FRESHNESS_VERIFY, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_CACHE_FRESHNESS_VERIFY_WHEN_EXPIRED,
+ "Set freshness verify to be when-expired", (char *) NULL);
+
+ createArgument("no-date", CMD_CONFIG_CACHE_FRESHNESS_VERIFY, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_CACHE_FRESHNESS_VERIFY_NO_DATE,
+ "Set freshness verify to be no-date", (char *) NULL);
+
+ createArgument("always", CMD_CONFIG_CACHE_FRESHNESS_VERIFY, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_CACHE_FRESHNESS_VERIFY_ALWALYS,
+ "Set freshness verify to be always", (char *) NULL);
+
+ createArgument("never", CMD_CONFIG_CACHE_FRESHNESS_VERIFY, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_CACHE_FRESHNESS_VERIFY_NEVER,
+ "Set the freshness verify to be never", (char *) NULL);
+
+ createArgument("minimum", CMD_CONFIG_CACHE_FRESHNESS, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_CACHE_FRESHNESS_MINIMUM,
+ "Set freshness minimum <explicit | last-modified | nothing>", (char *) NULL);
+
+ createArgument("explicit", CMD_CONFIG_CACHE_FRESHNESS_MINIMUM, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_CACHE_FRESHNESS_MINIMUM_EXPLICIT,
+ "Set the Freshness Minimum to be explicit", (char *) NULL);
+
+ createArgument("last-modified", CMD_CONFIG_CACHE_FRESHNESS_MINIMUM, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_CACHE_FRESHNESS_MINIMUM_LAST_MODIFIED,
+ "Set the Freshness Minimum to be last modified", (char *) NULL);
+
+ createArgument("nothing", CMD_CONFIG_CACHE_FRESHNESS_MINIMUM, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_CACHE_FRESHNESS_MINIMUM_NOTHING,
+ "Specify the Freshness minimum to be nothing", (char *) NULL);
+
+ createArgument("no-expire-limit", CMD_CONFIG_CACHE_FRESHNESS, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_CACHE_FRESHNESS_NO_EXPIRE_LIMIT,
+ "Set the Freshness no-expire-limit time", (char *) NULL);
+
+ createArgument("greater-than", CLI_ARGV_NO_POS, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_CACHE_FRESHNESS_NO_EXPIRE_LIMIT_GREATER_THAN,
+ "Set the minimum Freshness no-expire-limit time", (char *) NULL);
+
+ createArgument("less-than", CLI_ARGV_NO_POS, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_CACHE_FRESHNESS_NO_EXPIRE_LIMIT_LESS_THAN,
+ "Set the maximum Freshness no-expire-limit time", (char *) NULL);
+
+ createArgument("dynamic", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_CACHE_DYNAMIC, "Set Dynamic <on|off>", (char *) NULL);
+
+ createArgument("alternates", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_CACHE_ALTERNATES, "Set Alternates <on|off>", (char *) NULL);
+ createArgument("vary", 1, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_CACHE_VARY, "Set vary <text | images | other> <field>", (char *) NULL);
+ createArgument("text", CMD_CONFIG_CACHE_VARY, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_CACHE_VARY_TEXT, "Set vary text's value", (char *) NULL);
+ createArgument("images", CLI_ARGV_NO_POS, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_CACHE_VARY_COOKIES_IMAGES, "Set vary images' value", (char *) NULL);
+ createArgument("other", CMD_CONFIG_CACHE_VARY, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_CACHE_VARY_OTHER, "Set vary other's value", (char *) NULL);
+
+ createArgument("cookies", 1, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_CACHE_COOKIES, "Set cookies <none | all | images | non-text | non-text-ext>",
+ (char *) NULL);
+ createArgument("none", CMD_CONFIG_CACHE_COOKIES, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_CACHE_COOKIES_NONE, "No cookies", (char *) NULL);
+ createArgument("all", CMD_CONFIG_CACHE_COOKIES, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_CACHE_COOKIES_ALL, "All cookies", (char *) NULL);
+ createArgument("non-text", CMD_CONFIG_CACHE_COOKIES, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_CACHE_COOKIES_NON_TEXT, "Non-text cookies", (char *) NULL);
+ createArgument("non-text-ext", CMD_CONFIG_CACHE_COOKIES, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_CACHE_COOKIES_NON_TEXT_EXT, "Non-text-ext cookies", (char *) NULL);
+ createArgument("clear", 1, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_CACHE_CLEAR, "Clear the cache and start Traffic Server", (char *) NULL);
+ return 0;
+}
+
+
+
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigHostdb
+//
+// This is the callback function for the "config:hostdb" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigHostdb(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (cliCheckIfEnabled("config:hostdb") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+ Cli_Debug("Cmd_ConfigHostdb argc %d\n", argc);
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+ cli_parsedArgInfo *argtable;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ argtable = cmdCallbackInfo->parsedArgTable;
+
+ int action = (argc == 3) ? RECORD_SET : RECORD_GET;
+
+ if (argtable->parsed_args != CLI_PARSED_ARGV_END) {
+ switch (argtable->parsed_args) {
+ case CMD_CONFIG_HOSTDB_LOOKUP_TIMEOUT:
+ return (Cli_RecordInt_Action(action, "proxy.config.hostdb.lookup_timeout", argtable->arg_int));
+
+ case CMD_CONFIG_HOSTDB_FOREGROUND_TIMEOUT:
+ return (Cli_RecordInt_Action(action, "proxy.config.hostdb.timeout", argtable->arg_int));
+
+ case CMD_CONFIG_HOSTDB_BACKGROUND_TIMEOUT:
+ return (Cli_RecordInt_Action(action, "proxy.config.hostdb.verify_after", argtable->arg_int));
+
+ case CMD_CONFIG_HOSTDB_INVALID_HOST_TIMEOUT:
+ return (Cli_RecordInt_Action(action, "proxy.config.hostdb.fail.timeout", argtable->arg_int));
+
+ case CMD_CONFIG_HOSTDB_RE_DNS_ON_RELOAD:
+ return (Cli_RecordOnOff_Action(action, "proxy.config.hostdb.re_dns_on_reload", argtable->arg_string));
+ case CMD_CONFIG_HOSTDB_CLEAR:
+ return (ConfigHostdbClear());
+ }
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_ConfigHostdb
+//
+// Register "config:Hostdb" arguments with the Tcl interpreter.
+//
+int
+CmdArgs_ConfigHostdb()
+{
+ createArgument("lookup-timeout", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_HOSTDB_LOOKUP_TIMEOUT, "Lookup Timeout <seconds>", (char *) NULL);
+ createArgument("foreground-timeout", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_HOSTDB_FOREGROUND_TIMEOUT, "Foreground Timeout <minutes>", (char *) NULL);
+ createArgument("background-timeout", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_HOSTDB_BACKGROUND_TIMEOUT, "Background Timeout <minutes>", (char *) NULL);
+ createArgument("invalid-host-timeout", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_HOSTDB_INVALID_HOST_TIMEOUT, "Invalid Host Timeout <minutes>",
+ (char *) NULL);
+ createArgument("re-dns-on-reload", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_HOSTDB_RE_DNS_ON_RELOAD, "Re-DNS on Reload Timeout <on|off>", (char *) NULL);
+ createArgument("clear", 1, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_HOSTDB_CLEAR, "Clear the HostDB and start Traffic Server", (char *) NULL);
+ return 0;
+}
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigDns
+//
+// This is the callback function for the "config:dns" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigDns(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (cliCheckIfEnabled("config:dns") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+ Cli_Debug("Cmd_ConfigDns argc %d\n", argc);
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+ cli_parsedArgInfo *argtable;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ argtable = cmdCallbackInfo->parsedArgTable;
+
+ int action = (argc == 3) ? RECORD_SET : RECORD_GET;
+
+ if (argtable->parsed_args != CLI_PARSED_ARGV_END) {
+ switch (argtable->parsed_args) {
+ case CMD_CONFIG_DNS_RESOLVE_TIMEOUT:
+ return (Cli_RecordInt_Action(action, "proxy.config.dns.lookup_timeout", argtable->arg_int));
+
+ case CMD_CONFIG_DNS_RETRIES:
+ return (Cli_RecordInt_Action(action, "proxy.config.dns.retries", argtable->arg_int));
+ }
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_ConfigDns
+//
+// Register "config:dns" arguments with the Tcl interpreter.
+//
+int
+CmdArgs_ConfigDns()
+{
+ createArgument("resolve-timeout", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_DNS_RESOLVE_TIMEOUT, "Resolve timeout <int>", (char *) NULL);
+ createArgument("retries", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_DNS_RETRIES, "Number of retries <int>", (char *) NULL);
+
+ return 0;
+}
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigVirtualip
+//
+// This is the callback function for the "config:virtualip" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigVirtualip(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (cliCheckIfEnabled("config:virtualip") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+ Cli_Debug("Cmd_ConfigCache argc %d\n", argc);
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+ cli_parsedArgInfo *argtable;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ argtable = cmdCallbackInfo->parsedArgTable;
+
+ int setvar = 0;
+
+ if (argtable->parsed_args != CLI_PARSED_ARGV_END) {
+ switch (argtable->parsed_args) {
+ case CMD_CONFIG_VIRTUALIP_STATUS:
+ return (Cli_RecordOnOff_Action((argc == 3), "proxy.config.vmap.enabled", argtable->arg_string));
+
+ case CMD_CONFIG_VIRTUALIP_LIST:
+ return (ConfigVirtualIpList());
+
+ case CMD_CONFIG_VIRTUALIP_ADD:
+ if (argc == 8) {
+ setvar = 1;
+ }
+ Cli_PrintArg(0, argtable);
+ Cli_PrintArg(1, argtable);
+ Cli_PrintArg(2, argtable);
+ Cli_PrintArg(3, argtable);
+ if (ConfigVirtualipAdd(argtable[1].arg_string, argtable[2].arg_string, argtable[3].arg_int, setvar) == CLI_OK) {
+ return CMD_OK;
+ } else {
+ return CMD_ERROR;
+ }
+
+ case CMD_CONFIG_VIRTUALIP_DELETE:
+ if (argc == 3) {
+ setvar = 1;
+ }
+ if (ConfigVirtualipDelete(argtable[0].arg_int, setvar) == CLI_OK) {
+ return CMD_OK;
+ } else {
+ return CMD_ERROR;
+ }
+ }
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_ConfigVirtualip
+//
+// Register "config:virtualip" arguments with the Tcl interpreter.
+//
+int
+CmdArgs_ConfigVirtualip()
+{
+
+ createArgument("status", CLI_ARGV_NO_POS, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_VIRTUALIP_STATUS, "Virtual IP <on | off>", (char *) NULL);
+ createArgument("list", 1, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_VIRTUALIP_LIST, "List virtual IP addresses", (char *) NULL);
+ createArgument("add", 1, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_VIRTUALIP_ADD, "add ip <x.x.x.x> device <string> sub-intf <int>",
+ (char *) NULL);
+ createArgument("ip", CMD_CONFIG_VIRTUALIP_ADD, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_VIRTUALIP_ADD_IP, "Virtual IP Address <x.x.x.x>", (char *) NULL);
+ createArgument("device", CMD_CONFIG_VIRTUALIP_ADD_IP, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_VIRTUALIP_ADD_DEVICE, "Virtual IP device <string>", (char *) NULL);
+ createArgument("sub-intf", CMD_CONFIG_VIRTUALIP_ADD_DEVICE, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_VIRTUALIP_ADD_SUBINTERFACE, "Virtual IP sub interface <integer>",
+ (char *) NULL);
+ createArgument("delete", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_VIRTUALIP_DELETE, "Delete Virtual IP <integer>", (char *) NULL);
+ return CLI_OK;
+}
+
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigLogging
+//
+// This is the callback function for the "config:logging" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigLogging(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (cliCheckIfEnabled("config:logging") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+ Cli_Debug("Cmd_ConfigCache argc %d\n", argc);
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+ cli_parsedArgInfo *argtable;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ argtable = cmdCallbackInfo->parsedArgTable;
+
+ int setvar = 0;
+
+ if (argtable->parsed_args != CLI_PARSED_ARGV_END) {
+ switch (argtable->parsed_args) {
+ case CMD_CONFIG_LOGGING_EVENT:
+ if (argc == 3) {
+ setvar = 1;
+ }
+ return (ConfigLoggingEvent(argtable[1].parsed_args, setvar));
+ case CMD_CONFIG_LOGGING_MGMT_DIRECTORY:
+ return (Cli_RecordString_Action((argc == 3), "proxy.config.log.logfile_dir", argtable->arg_string));
+
+ case CMD_CONFIG_LOGGING_SPACE_LIMIT:
+ return (Cli_RecordInt_Action((argc == 3), "proxy.config.log.max_space_mb_for_logs", argtable->arg_int));
+
+ case CMD_CONFIG_LOGGING_SPACE_HEADROOM:
+ return (Cli_RecordInt_Action((argc == 3), "proxy.config.log.max_space_mb_headroom", argtable->arg_int));
+
+ case CMD_CONFIG_LOGGING_COLLATION_STATUS:
+ if (argc == 3) {
+ setvar = 1;
+ }
+ return (ConfigLoggingCollationStatus(argtable[1].parsed_args, setvar));
+ case CMD_CONFIG_LOGGING_COLLATION_HOST:
+ return (Cli_RecordString_Action((argc == 3), "proxy.config.log.collation_host", argtable->arg_string));
+
+ case CMD_CONFIG_LOGGING_COLLATION:
+ if (argc == 8) {
+ setvar = 1;
+ }
+ Cli_PrintArg(1, argtable);
+ Cli_PrintArg(2, argtable);
+ Cli_PrintArg(3, argtable);
+ Cli_PrintArg(4, argtable);
+ return (ConfigLoggingCollation(argtable[1].arg_string, argtable[3].parsed_args, argtable[4].arg_int, setvar));
+ case CMD_CONFIG_LOGGING_AND_CUSTOM_FORMAT:
+ if (argc == 10) {
+ setvar = 1;
+ }
+ Cli_PrintArg(1, argtable);
+ Cli_PrintArg(2, argtable);
+ Cli_PrintArg(3, argtable);
+ Cli_PrintArg(4, argtable);
+ Cli_PrintArg(5, argtable);
+ Cli_PrintArg(6, argtable);
+ return (ConfigLoggingFormatTypeFile(argtable[1].parsed_args,
+ argtable[2].parsed_args,
+ argtable[4].parsed_args,
+ argtable[5].arg_string, argtable[6].arg_string, setvar));
+ case CMD_CONFIG_LOGGING_SPLITTING:
+ if (argc == 4) {
+ setvar = 1;
+ }
+ Cli_PrintArg(1, argtable);
+ Cli_PrintArg(2, argtable);
+ return (ConfigLoggingSplitting(argtable[1].parsed_args, argtable[2].parsed_args, setvar));
+
+ case CMD_CONFIG_LOGGING_CUSTOM:
+ if (argc == 5) {
+ setvar = 1;
+ }
+ Cli_PrintArg(1, argtable);
+ Cli_PrintArg(2, argtable);
+ Cli_PrintArg(3, argtable);
+ return (ConfigLoggingCustomFormat(argtable[1].parsed_args, argtable[3].parsed_args, setvar));
+
+ case CMD_CONFIG_LOGGING_ROLLING:
+ if (argc == 9) {
+ setvar = 1;
+ }
+ Cli_PrintArg(1, argtable);
+ Cli_PrintArg(2, argtable);
+ Cli_PrintArg(3, argtable);
+ Cli_PrintArg(4, argtable);
+ Cli_PrintArg(5, argtable);
+ return (ConfigLoggingRollingOffsetIntervalAutodelete(argtable[1].parsed_args,
+ argtable[2].arg_int,
+ argtable[3].arg_int, argtable[5].parsed_args, setvar));
+
+ }
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_ConfigLogging
+//
+// Register "config:logging" arguments with the Tcl interpreter.
+//
+int
+CmdArgs_ConfigLogging()
+{
+
+ createArgument("on", CLI_ARGV_NO_POS, CLI_ARGV_REQUIRED,
+ (char *) NULL, CMD_CONFIG_LOGGING_ON, "Enable logging", (char *) NULL);
+ createArgument("off", CLI_ARGV_NO_POS, CLI_ARGV_REQUIRED,
+ (char *) NULL, CMD_CONFIG_LOGGING_OFF, "Disable logging", (char *) NULL);
+ createArgument("event", 1, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_LOGGING_EVENT, "Events <enabled | trans-only | error-only | disabled>",
+ (char *) NULL);
+ createArgument("enabled", CMD_CONFIG_LOGGING_EVENT, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_LOGGING_EVENT_ENABLED, "Event logging enabled", (char *) NULL);
+ createArgument("trans-only", CMD_CONFIG_LOGGING_EVENT, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_LOGGING_EVENT_TRANS_ONLY, "Event logging for transactions only",
+ (char *) NULL);
+ createArgument("error-only", CMD_CONFIG_LOGGING_EVENT, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_LOGGING_EVENT_ERROR_ONLY, "Event logging for errors only", (char *) NULL);
+ createArgument("disabled", CMD_CONFIG_LOGGING_EVENT, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_LOGGING_EVENT_DISABLED, "Event logging is disabled", (char *) NULL);
+ createArgument("mgmt-directory", 1, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_LOGGING_MGMT_DIRECTORY, "Logging MGMT directory <string>", (char *) NULL);
+ createArgument("space-limit", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_LOGGING_SPACE_LIMIT, "Space limit for logs <mb>", (char *) NULL);
+ createArgument("space-headroom", 1, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_LOGGING_SPACE_HEADROOM, "Space for headroom <mb>", (char *) NULL);
+ createArgument("collation-status", 1, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_LOGGING_COLLATION_STATUS,
+ "Collation status <inactive | host | send-standard |\n" " send-custom | send-all>",
+ (char *) NULL);
+ createArgument("inactive", CMD_CONFIG_LOGGING_COLLATION_STATUS, CLI_ARGV_CONSTANT, (char *) NULL,
+ CMD_CONFIG_LOGGING_COLLATION_STATUS_INACTIVE, "No collation", (char *) NULL);
+ createArgument("host", CMD_CONFIG_LOGGING_COLLATION_STATUS, CLI_ARGV_CONSTANT, (char *) NULL,
+ CMD_CONFIG_LOGGING_COLLATION_STATUS_HOST, "Be a collation host (receiver)", (char *) NULL);
+ createArgument("send-standard", CMD_CONFIG_LOGGING_COLLATION_STATUS, CLI_ARGV_OPTION_NAME_VALUE, (char *) NULL,
+ CMD_CONFIG_LOGGING_COLLATION_STATUS_SEND_STANDARD, "Send standard logs", (char *) NULL);
+ createArgument("send-custom", CMD_CONFIG_LOGGING_COLLATION_STATUS, CLI_ARGV_OPTION_NAME_VALUE, (char *) NULL,
+ CMD_CONFIG_LOGGING_COLLATION_STATUS_SEND_CUSTOM, "Send custom logs", (char *) NULL);
+ createArgument("send-all", CMD_CONFIG_LOGGING_COLLATION_STATUS, CLI_ARGV_OPTION_NAME_VALUE, (char *) NULL,
+ CMD_CONFIG_LOGGING_COLLATION_STATUS_SEND_ALL, "Send all logs", (char *) NULL);
+ createArgument("collation-host", 1, CLI_ARGV_OPTION_NAME_VALUE, (char *) NULL, CMD_CONFIG_LOGGING_COLLATION_HOST,
+ "Specify the collation host <string>", (char *) NULL);
+
+ createArgument("collation", 1, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_LOGGING_COLLATION, "Collation parameters secret <secret> tagged <on | off>\n"
+ " orphan-limit <orphan>", (char *) NULL);
+
+ createArgument("secret", CMD_CONFIG_LOGGING_COLLATION, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_LOGGING_COLLATION_SECRET, "Collation secret is <string>", (char *) NULL);
+
+ createArgument("tagged", CLI_ARGV_NO_POS, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_LOGGING_COLLATION_TAGGED, "Collation tagged is <on | off>", (char *) NULL);
+
+ createArgument("orphan-limit", CLI_ARGV_NO_POS, CLI_ARGV_INT,
+ (char *) NULL, CMD_CONFIG_LOGGING_COLLATION_ORPHAN_LIMIT,
+ "Collation orphan limit size <mb>", (char *) NULL);
+
+ createArgument("format", CLI_ARGV_NO_POS, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_LOGGING_AND_CUSTOM_FORMAT,
+ "Logging format <squid | netscape-common | netscape-ext |\n"
+ " netscape-ext2>", (char *) NULL);
+
+ createArgument("squid", CMD_CONFIG_LOGGING_AND_CUSTOM_FORMAT, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_LOGGING_FORMAT_SQUID, "Squid <on | off>", (char *) NULL);
+ createArgument("netscape-common", CMD_CONFIG_LOGGING_AND_CUSTOM_FORMAT, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_LOGGING_FORMAT_NETSCAPE_COMMON, "Netscape Common <on | off>", (char *) NULL);
+ createArgument("netscape-ext", CMD_CONFIG_LOGGING_AND_CUSTOM_FORMAT, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_LOGGING_FORMAT_NETSCAPE_EXT, "Netscape Extended <on | off>", (char *) NULL);
+ createArgument("netscape-ext2", CMD_CONFIG_LOGGING_AND_CUSTOM_FORMAT, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_LOGGING_FORMAT_NETSCAPE_EXT2,
+ "Netscape Extended 2 <on | off>", (char *) NULL);
+
+ createArgument("type", CLI_ARGV_NO_POS, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_LOGGING_TYPE, "Logging type <ascii | binary>", (char *) NULL);
+ createArgument("ascii", CMD_CONFIG_LOGGING_TYPE, CLI_ARGV_REQUIRED,
+ (char *) NULL, CMD_CONFIG_LOGGING_TYPE_ASCII, "ASCII log files", (char *) NULL);
+ createArgument("binary", CMD_CONFIG_LOGGING_TYPE, CLI_ARGV_REQUIRED,
+ (char *) NULL, CMD_CONFIG_LOGGING_TYPE_BINARY, "Binary log files", (char *) NULL);
+
+ createArgument("file", CLI_ARGV_NO_POS, CLI_ARGV_STRING,
+ (char *) NULL, CMD_CONFIG_LOGGING_FILE, "Log file name <string>", (char *) NULL);
+
+ createArgument("header", CLI_ARGV_NO_POS, CLI_ARGV_STRING,
+ (char *) NULL, CMD_CONFIG_LOGGING_HEADER, "Log file header <string>", (char *) NULL);
+
+ createArgument("splitting", 1, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_LOGGING_SPLITTING,
+ "Splitting of logs for protocols <icp | http>", (char *) NULL);
+ createArgument("icp", CMD_CONFIG_LOGGING_SPLITTING, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_LOGGING_SPLITTING_ICP, "Split ICP <on | off>", (char *) NULL);
+ createArgument("http", CMD_CONFIG_LOGGING_SPLITTING, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_LOGGING_SPLITTING_HTTP, "Split of HTTP <on | off>", (char *) NULL);
+
+ createArgument("custom", 1, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_LOGGING_CUSTOM,
+ "Custom Logging <on | off>", (char *) NULL);
+
+ createArgument("rolling", 1, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_LOGGING_ROLLING,
+ "Log file rolling <on | off> offset <hour>\n"
+ " interval <num-hours> auto-delete <on | off>", (char *) NULL);
+
+ createArgument("offset", CLI_ARGV_NO_POS, CLI_ARGV_INT,
+ (char *) NULL, CMD_CONFIG_LOGGING_OFFSET, "Rolling offset <hour> (24hour format)", (char *) NULL);
+
+ createArgument("interval", CLI_ARGV_NO_POS, CLI_ARGV_INT,
+ (char *) NULL, CMD_CONFIG_LOGGING_INTERVAL, "Rolling interval <seconds>", (char *) NULL);
+ createArgument("auto-delete", CLI_ARGV_NO_POS, CLI_ARGV_CONST_OPTION,
+ (char *) NULL, CMD_CONFIG_LOGGING_AUTO_DELETE, "Auto delete <on | off>", (char *) NULL);
+ return 0;
+
+
+}
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigSsl
+//
+// This is the callback function for the "config:ssl" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigSsl(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (cliCheckIfEnabled("config:ssl") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+ Cli_Debug("Cmd_ConfigSsl argc %d\n", argc);
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+ cli_parsedArgInfo *argtable;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ argtable = cmdCallbackInfo->parsedArgTable;
+
+ int action = (argc == 3) ? RECORD_SET : RECORD_GET;
+
+ if (argtable->parsed_args != CLI_PARSED_ARGV_END) {
+ switch (argtable->parsed_args) {
+ case CMD_CONFIG_SSL_STATUS:
+ return (Cli_RecordOnOff_Action(action, "proxy.config.ssl.enabled", argtable->arg_string));
+
+ case CMD_CONFIG_SSL_PORT:
+ return (Cli_RecordInt_Action(action, "proxy.config.ssl.server_port", argtable->arg_int));
+ }
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_ConfigSsl
+//
+// Register "config:ssl" arguments with the Tcl interpreter.
+//
+int
+CmdArgs_ConfigSsl()
+{
+ createArgument("status", CLI_ARGV_NO_POS, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_SSL_STATUS, "SSL <on | off>", (char *) NULL);
+
+ createArgument("ports", CLI_ARGV_NO_POS, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_SSL_PORT, "SSL port <int>", (char *) NULL);
+ return 0;
+}
+
+
+////////////////////////////////////////////////////////////////
+// Cmd_ConfigAlarm
+//
+// This is the callback function for the "config:alarm" command.
+//
+// Parameters:
+// clientData -- information about parsed arguments
+// interp -- the Tcl interpreter
+// argc -- number of command arguments
+// argv -- the command arguments
+//
+int
+Cmd_ConfigAlarm(ClientData clientData, Tcl_Interp * interp, int argc, const char *argv[])
+{
+ /* call to processArgForCommand must appear at the beginning
+ * of each command's callback function
+ */
+ if (processArgForCommand(interp, argc, argv) != CLI_OK) {
+ return CMD_ERROR;
+ }
+
+ if (processHelpCommand(argc, argv) == CLI_OK)
+ return CMD_OK;
+
+ if (cliCheckIfEnabled("config:alarm") == CLI_ERROR) {
+ return CMD_ERROR;
+ }
+ Cli_Debug("Cmd_ConfigAlarm argc %d\n", argc);
+
+ cli_cmdCallbackInfo *cmdCallbackInfo;
+ cli_parsedArgInfo *argtable;
+
+ cmdCallbackInfo = (cli_cmdCallbackInfo *) clientData;
+ argtable = cmdCallbackInfo->parsedArgTable;
+
+ if (argtable->parsed_args != CLI_PARSED_ARGV_END) {
+ switch (argtable->parsed_args) {
+ case CMD_CONFIG_ALARM_RESOLVE_NAME:
+ if (argc < 3) {
+ return (ShowAlarms());
+ }
+ return (ConfigAlarmResolveName(argtable->arg_string));
+ case CMD_CONFIG_ALARM_RESOLVE_NUMBER:
+ if (argc < 3) {
+ return (ShowAlarms());
+ }
+ return (ConfigAlarmResolveNumber(argtable->arg_int));
+ case CMD_CONFIG_ALARM_RESOLVE_ALL:
+ return (ConfigAlarmResolveAll());
+ case CMD_CONFIG_ALARM_NOTIFY:
+ Cli_Debug("Cmd_ConfigAlarm \"%s\"\n", argtable->arg_string);
+ return (ConfigAlarmNotify(argtable->arg_string));
+ }
+ }
+ Cli_Error(ERR_COMMAND_SYNTAX, cmdCallbackInfo->command_usage);
+ return CMD_ERROR;
+}
+
+
+
+////////////////////////////////////////////////////////////////
+// CmdArgs_ConfigAlarm
+//
+// Register "config:alarm" arguments with the Tcl interpreter.
+//
+int
+CmdArgs_ConfigAlarm()
+{
+ createArgument("resolve-name", CLI_ARGV_NO_POS, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_ALARM_RESOLVE_NAME, "Resolve by name <string>", (char *) NULL);
+
+ createArgument("resolve-number", CLI_ARGV_NO_POS, CLI_ARGV_OPTION_INT_VALUE,
+ (char *) NULL, CMD_CONFIG_ALARM_RESOLVE_NUMBER, "Resolve by number from list <int>", (char *) NULL);
+
+ createArgument("resolve-all", CLI_ARGV_NO_POS, CLI_ARGV_CONSTANT,
+ (char *) NULL, CMD_CONFIG_ALARM_RESOLVE_ALL, "Resolve all alarms", (char *) NULL);
+
+ createArgument("notify", CLI_ARGV_NO_POS, CLI_ARGV_OPTION_NAME_VALUE,
+ (char *) NULL, CMD_CONFIG_ALARM_NOTIFY, "Alarm notification <on | off>", (char *) NULL);
+ return CLI_OK;
+}
+
+
+////////////////////////////////////////////////////////////////
+//
+// "config" sub-command implementations
+//
+////////////////////////////////////////////////////////////////
+
+
+// config start sub-command
+int
+ConfigStart()
+{
+ TSProxyStateT state = TSProxyStateGet();
+
+ switch (state) {
+ case TS_PROXY_ON:
+ // do nothing, proxy is already on
+ Cli_Error(ERR_PROXY_STATE_ALREADY, "on");
+ break;
+ case TS_PROXY_OFF:
+ case TS_PROXY_UNDEFINED:
+ if (TSProxyStateSet(TS_PROXY_ON, TS_CACHE_CLEAR_OFF)) {
+ Cli_Error(ERR_PROXY_STATE_SET, "on");
+ return CLI_ERROR;
+ }
+ break;
+ }
+ return CLI_OK;
+}
+
+// config stop sub-command
+int
+ConfigStop()
+{
+ TSProxyStateT state = TSProxyStateGet();
+
+ switch (state) {
+ case TS_PROXY_OFF:
+ // do nothing, proxy is already off
+ Cli_Error(ERR_PROXY_STATE_ALREADY, "off");
+ break;
+ case TS_PROXY_ON:
+ case TS_PROXY_UNDEFINED:
+ if (TSProxyStateSet(TS_PROXY_OFF, TS_CACHE_CLEAR_OFF)) {
+ Cli_Error(ERR_PROXY_STATE_SET, "off");
+ return CLI_ERROR;
+ }
+ break;
+ }
+ return CLI_OK;
+}
+
+// config get sub-command
+// used to get the value of any config variable in records.config
+int
+ConfigGet(const char *rec_name)
+{
+ Cli_Debug("ConfigGet: rec_name %s\n", rec_name);
+
+ TSError status;
+ TSRecordEle rec_val;
+
+ status = Cli_RecordGet(rec_name, &rec_val);
+
+ if (status) {
+ return status;
+ }
+ // display the result
+
+ switch (rec_val.rec_type) {
+ case TS_REC_INT: // TS64 aka "long long"
+ Cli_Printf("%s = %d\n", rec_name, (int) rec_val.int_val);
+ break;
+ case TS_REC_COUNTER: // TS64 aka "long long"
+ Cli_Printf("%s = %d\n", rec_name, (int) rec_val.counter_val);
+ break;
+ case TS_REC_FLOAT: // float
+ Cli_Printf("%s = %f\n", rec_name, rec_val.float_val);
+ break;
+ case TS_REC_STRING: // char*
+ Cli_Printf("%s = \"%s\"\n", rec_name, rec_val.string_val);
+ break;
+ case TS_REC_UNDEFINED: // what's this???
+ Cli_Printf("%s = UNDEFINED\n", rec_name);
+ break;
+ }
+
+ return CLI_OK;
+}
+
+// config set sub-command
+// used to set the value of any variable in records.config
+
+int
+ConfigSet(const char *rec_name, const char *value)
+{
+ Cli_Debug("ConfigSet: rec_name %s value %s\n", rec_name, value);
+
+ TSError status;
+ TSActionNeedT action_need;
+
+ status = Cli_RecordSet(rec_name, value, &action_need);
+ if (status) {
+ return status;
+ }
+
+ return (Cli_ConfigEnactChanges(action_need));
+}
+
+// config name sub-command
+// used to set or display the value of proxy.config.proxy_name
+
+int
+ConfigName(const char *proxy_name)
+{
+ TSError status = TS_ERR_OKAY;
+ TSString str_val = NULL;
+ TSActionNeedT action_need;
+
+ if (proxy_name) { // set the name
+
+ Cli_Debug("ConfigName: set name proxy_name %s\n", proxy_name);
+
+ status = Cli_RecordSetString("proxy.config.proxy_name", (TSString) proxy_name, &action_need);
+
+ if (status) {
+ return status;
+ }
+
+ return (Cli_ConfigEnactChanges(action_need));
+
+ }
+
+ else { // display the name
+ Cli_Debug("ConfigName: get name\n");
+
+ status = Cli_RecordGetString("proxy.config.proxy_name", &str_val);
+ if (status) {
+ return status;
+ }
+
+ if (str_val) {
+ Cli_Printf("%s\n", str_val);
+ } else {
+ Cli_Printf("none\n");
+ }
+ }
+
+ return CLI_OK;
+
+}
+
+// config ports sub-command
+// used to set the value of port(s)
+
+int
+ConfigPortsSet(int arg_ref, void *valuePtr)
+{
+
+ switch (arg_ref) {
+ case CMD_CONFIG_PORTS_CONNECT:
+ Cli_Debug("ConfigPortsSet: arg_ref %d value %s\n", arg_ref, (char *) valuePtr);
+ break;
+ default:
+ Cli_Debug("ConfigPortsSet: arg_ref %d value %d\n", arg_ref, *(TSInt *) valuePtr);
+ }
+
+ TSError status = TS_ERR_OKAY;
+ TSActionNeedT action_need = TS_ACTION_UNDEFINED;
+
+ Cli_Debug("ConfigPorts: set\n");
+ switch (arg_ref) {
+ case CMD_CONFIG_PORTS_HTTP_SERVER:
+ status = Cli_RecordSetInt("proxy.config.http.server_port", *(TSInt *) valuePtr, &action_need);
+ break;
+ case CMD_CONFIG_PORTS_CLUSTER:
+ status = Cli_RecordSetInt("proxy.config.cluster.cluster_port", *(TSInt *) valuePtr, &action_need);
+ break;
+ case CMD_CONFIG_PORTS_CLUSTER_RS:
+ status = Cli_RecordSetInt("proxy.config.cluster.rsport", *(TSInt *) valuePtr, &action_need);
+ break;
+ case CMD_CONFIG_PORTS_CLUSTER_MC:
+ status = Cli_RecordSetInt("proxy.config.cluster.mcport", *(TSInt *) valuePtr, &action_need);
+ break;
+ case CMD_CONFIG_PORTS_CONNECT:
+ status = Cli_RecordSetString("proxy.config.http.connect_ports", (TSString) valuePtr, &action_need);
+ break;
+ case CMD_CONFIG_PORTS_SOCKS_SERVER:
+ status = Cli_RecordSetInt("proxy.config.socks.socks_server_port", *(TSInt *) valuePtr, &action_need);
+ break;
+ case CMD_CONFIG_PORTS_ICP:
+ status = Cli_RecordSetInt("proxy.config.icp.icp_port", *(TSInt *) valuePtr, &action_need);
+ break;
+ }
+
+ if (status) {
+ return status;
+ }
+
+ return (Cli_ConfigEnactChanges(action_need));
+
+}
+
+// config ports sub-command
+// used to display the value of port(s)
+
+int
+ConfigPortsGet(int arg_ref)
+{
+ TSError status = TS_ERR_OKAY;
+ TSInt int_val = -1;
+ TSString str_val = NULL;
+
+ Cli_Debug("ConfigPortsGet: get\n");
+
+ switch (arg_ref) {
+ case CMD_CONFIG_PORTS_HTTP_SERVER:
+ status = Cli_RecordGetInt("proxy.config.http.server_port", &int_val);
+ if (status) {
+ return status;
+ }
+ Cli_Printf("%d\n", int_val);
+ break;
+ case CMD_CONFIG_PORTS_CLUSTER:
+ status = Cli_RecordGetInt("proxy.config.cluster.cluster_port", &int_val);
+ if (status) {
+ return status;
+ }
+ Cli_Printf("%d\n", i
<TRUNCATED>