sergiotarxz/nuttx-apps
sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

chat app and required update to the pppd client.

Browse Source
This commit is contained in:
Vladimir Komendantskiy 2016-01-29 17:00:59 -06:00 committed by Gregory Nutt
parent 694d6b4010
commit 387dda152c
21 changed files with 1648 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
examples/Kconfig
View File

@ -12,6 +12,7 @@ source "$APPSDIR/examples/bridge/Kconfig"
source "$APPSDIR/examples/buttons/Kconfig"
source "$APPSDIR/examples/can/Kconfig"
source "$APPSDIR/examples/cc3000/Kconfig"
source "$APPSDIR/examples/chat/Kconfig"
source "$APPSDIR/examples/configdata/Kconfig"
source "$APPSDIR/examples/cpuhog/Kconfig"
source "$APPSDIR/examples/cxxtest/Kconfig"

19
examples/README.txt
View File

@ -192,6 +192,23 @@ examples/cc3000
This is a test for the TI CC3000 wireless networking module.
examples/chat
^^^^^^^^^^^^^
Demonstrates AT chat functionality over a TTY device. This is useful with AT
modems, for example, to establish a pppd connection (see the related pppd
example). Moreover, some AT modems - such as ones made by u-blox - have an
internal TCP/IP stack, often with an implementation of TLS/SSL. In such cases
the chat utility can be used to configure the internal TCP/IP stack, establish
socket connections, set up security (e.g., download base64-encoded
certificates to the modem), and perform data exchange through sockets over the
TTY device.
Useful configuration parameters:
CONFIG_EXAMPLES_CHAT_PRESET[0..3] - preset chat scripts
CONFIG_EXAMPLES_CHAT_TTY_DEVNODE - TTY device node name
CONFIG_EXAMPLES_CHAT_TIMEOUT_SECONDS - default receive timeout
examples/configdata
^^^^^^^^^^^^^^^^^^^
@ -2005,7 +2022,7 @@ examples/unionfs
CONFIG_FS_UNIONFS - Union File System support is required
Configuration options. Use the defaults if you are unsure of what you are doing:
CONFIG_EXAMPLES_UNIONFS - Enables the example
CONFIG_EXAMPLES_UNIONFS_MOUNTPT - Mountpoint path for the Union File System
CONFIG_EXAMPLES_UNIONFS_TMPA - Temporary mount point for file system 1

59
examples/chat/Kconfig Normal file
View File

@ -0,0 +1,59 @@
#
# For a description of the syntax of this configuration file,
# see the file kconfig-language.txt in the NuttX tools repository.
#
menuconfig EXAMPLES_CHAT
bool "AT modem chat utility"
default n
select NETUTILS_CHAT
---help---
Enable the AT chat utility.
if EXAMPLES_CHAT
config EXAMPLES_CHAT_TTY_DEVNODE
string "default modem chat TTY device node"
default "/dev/ttyS1"
---help---
TTY device node used by modem chat.
config EXAMPLES_CHAT_TIMEOUT_SECONDS
int "default modem timeout (sec)"
default 20
---help---
The default timeout in seconds for the expected string to be
received.
config EXAMPLES_CHAT_SIZE
int "maximum chat script file size"
default 1024
---help---
Maximum size of a chat script file, in bytes. Used for run-time
buffer allocation when reading from file.
config EXAMPLES_CHAT_PRESET0
string "preset script 0"
default ""
---help---
Preset chat script number 0.
config EXAMPLES_CHAT_PRESET1
string "preset script 1"
default ""
---help---
Preset chat script number 1.
config EXAMPLES_CHAT_PRESET2
string "preset script 2"
default ""
---help---
Preset chat script number 2.
config EXAMPLES_CHAT_PRESET3
string "preset script 3"
default ""
---help---
Preset chat script number 3.
endif # EXAMPLES_CHAT

39
examples/chat/Make.defs Normal file
View File

@ -0,0 +1,39 @@
############################################################################
# apps/examples/chat/Make.defs
# Adds selected applications to apps/ build
#
# Copyright (C) 2016 Vladimir Komendantskiy. All rights reserved.
# Author: Vladimir Komendantskiy <vladimir@moixaenergy.com>
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# 3. Neither the name NuttX nor the names of its contributors may be
# used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
############################################################################
ifeq ($(CONFIG_EXAMPLES_CHAT),y)
CONFIGURED_APPS += examples/chat
endif

132
examples/chat/Makefile Normal file
View File

@ -0,0 +1,132 @@
############################################################################
# apps/examples/chat/Makefile
#
# Copyright (C) 2016 Vladimir Komendantskiy. All rights reserved.
# Author: Vladimir Komendantskiy <vladimir@moixaenergy.com>
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# 3. Neither the name NuttX nor the names of its contributors may be
# used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
############################################################################
-include $(TOPDIR)/.config
-include $(TOPDIR)/Make.defs
include $(APPDIR)/Make.defs
ASRCS =
CSRCS =
MAINSRC = chat_main.c
AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT))
MAINOBJ = $(MAINSRC:.c=$(OBJEXT))
SRCS = $(ASRCS) $(CSRCS) $(MAINSRC)
OBJS = $(AOBJS) $(COBJS)
ifneq ($(CONFIG_BUILD_KERNEL),y)
OBJS += $(MAINOBJ)
endif
ifeq ($(CONFIG_WINDOWS_NATIVE),y)
BIN = ..\..\libapps$(LIBEXT)
else
ifeq ($(WINTOOL),y)
BIN = ..\\..\\libapps$(LIBEXT)
else
BIN = ../../libapps$(LIBEXT)
endif
endif
ifeq ($(WINTOOL),y)
INSTALL_DIR = "${shell cygpath -w $(BIN_DIR)}"
else
INSTALL_DIR = $(BIN_DIR)
endif
CONFIG_XYZ_PROGNAME ?= chat$(EXEEXT)
PROGNAME = $(CONFIG_XYZ_PROGNAME)
ROOTDEPPATH = --dep-path .
VPATH =
APPNAME = chat
PRIORITY = SCHED_PRIORITY_DEFAULT
STACKSIZE = 2048
# Build targets
all: .built
.PHONY: context .depend depend clean distclean
$(AOBJS): %$(OBJEXT): %.S
$(call ASSEMBLE, $<, $@)
$(COBJS) $(MAINOBJ): %$(OBJEXT): %.c
$(call COMPILE, $<, $@)
.built: $(OBJS)
$(call ARCHIVE, $(BIN), $(OBJS))
$(Q) touch .built
ifeq ($(CONFIG_BUILD_KERNEL),y)
$(BIN_DIR)$(DELIM)$(PROGNAME): $(OBJS) $(MAINOBJ)
@echo "LD: $(PROGNAME)"
$(Q) $(LD) $(LDELFFLAGS) $(LDLIBPATH) -o $(INSTALL_DIR)$(DELIM)$(PROGNAME) $(ARCHCRT0OBJ) $(MAINOBJ) $(LDLIBS)
$(Q) $(NM) -u $(INSTALL_DIR)$(DELIM)$(PROGNAME)
install: $(BIN_DIR)$(DELIM)$(PROGNAME)
else
install:
endif
ifeq ($(CONFIG_NSH_BUILTIN_APPS),y)
$(BUILTIN_REGISTRY)$(DELIM)$(APPNAME)_main.bdat: $(DEPCONFIG) Makefile
$(call REGISTER,$(APPNAME),$(PRIORITY),$(STACKSIZE),$(APPNAME)_main)
context: $(BUILTIN_REGISTRY)$(DELIM)$(APPNAME)_main.bdat
else
context:
endif
.depend: Makefile $(SRCS)
$(Q) $(MKDEP) $(ROOTDEPPATH) "$(CC)" -- $(CFLAGS) -- $(SRCS) >Make.dep
$(Q) touch $@
depend: .depend
clean:
$(call DELFILE, .built)
$(call CLEAN)
distclean: clean
$(call DELFILE, Make.dep)
$(call DELFILE, .depend)
-include Make.dep

395
examples/chat/chat_main.c Normal file
View File

@ -0,0 +1,395 @@
/****************************************************************************
* apps/examples/chat/chat_main.c
*
* Copyright (C) 2016 Vladimir Komendantskiy. All rights reserved.
* Author: Vladimir Komendantskiy <vladimir@moixaenergy.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <apps/netutils/chat.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define CHAT_TTYNAME_SIZE 32
/****************************************************************************
* Private Types
****************************************************************************/
/* Chat app private state. A supertype of 'chat_ctl'. */
struct chat_app
{
struct chat_ctl ctl; /* Embedded 'chat_ctl' type. */
/* Private fields */
int argc; /* number of command-line arguments */
FAR char** argv; /* command-line arguments */
char tty[CHAT_TTYNAME_SIZE]; /* modem TTY device node */
FAR char* script; /* raw chat script - input to the parser */
bool script_dynalloc; /* true iff the script should be freed */
};
/****************************************************************************
* Private Data
****************************************************************************/
/* Preset chat scripts */
FAR char g_chat_script0[] = CONFIG_EXAMPLES_CHAT_PRESET0;
FAR char g_chat_script1[] = CONFIG_EXAMPLES_CHAT_PRESET1;
FAR char g_chat_script2[] = CONFIG_EXAMPLES_CHAT_PRESET2;
FAR char g_chat_script3[] = CONFIG_EXAMPLES_CHAT_PRESET3;
/****************************************************************************
* Private Functions
****************************************************************************/
static void chat_show_usage(void)
{
printf("Usage: chat [options]\n"
" where [options] is a possibly empty list of\n"
"-d<file> : modem TTY device node\n"
"-e : echo modem output to stderr\n"
"-f<file> : chat script file\n"
"-p<number> : preprogrammed script\n"
"-t<number> : default modem response timeout\n"
"-v : verbose mode\n");
}
static int chat_chardev(FAR struct chat_app* priv)
{
int flags;
flags = fcntl(priv->ctl.fd, F_GETFL, 0);
if (flags < 0)
{
return flags;
}
flags = fcntl(priv->ctl.fd, F_SETFL, flags | O_NONBLOCK);
if (flags < 0)
{
return flags;
}
return 0;
}
static int chat_script_preset(FAR struct chat_app* priv, int script_number)
{
int ret = 0;
vdbg("preset script %d\n", script_number);
switch (script_number)
{
case 0:
priv->script = g_chat_script0;
break;
case 1:
priv->script = g_chat_script1;
break;
case 2:
priv->script = g_chat_script2;
break;
case 3:
priv->script = g_chat_script3;
break;
default:
ret = -ERANGE;
break;
}
return ret;
}
static int chat_script_read(FAR struct chat_app* priv,
FAR const char* filepath)
{
FAR char* scriptp;
size_t spare_size = CONFIG_EXAMPLES_CHAT_SIZE-1;
ssize_t read_size;
bool eof = false;
int ret = 0;
int fd;
priv->script = malloc(CONFIG_EXAMPLES_CHAT_SIZE);
if (!priv->script)
{
return -ENOMEM;
}
priv->script_dynalloc = true;
scriptp = priv->script;
memset(scriptp, 0, CONFIG_EXAMPLES_CHAT_SIZE);
fd = open(filepath, O_RDONLY);
if (fd < 0)
{
fprintf(stderr, "Cannot open %s, error %d\n", filepath, errno);
ret = -ENOENT;
}
while (!ret && !eof && spare_size > 0)
{
read_size = read(fd, scriptp, spare_size);
if (read_size < 0)
{
/* EINTR is not a read error. It simply means that a signal was
* received while waiting for the read to complete.
*/
if (errno != EINTR)
{
fprintf(stderr, "Cannot read %s, error %d\n",
filepath, errno);
ret = -EIO;
}
}
else if (read_size == 0)
{
eof = true;
}
else
{
/* read_size > 0 */
DEBUGASSERT(read_size <= spare_size);
scriptp += read_size;
spare_size -= read_size;
}
}
close(fd);
return ret;
}
static int chat_parse_args(FAR struct chat_app* priv)
{
/*
* -d TTY device node (non-Linux feature)
* -e echo to stderr
* -f script file
* -p preprogrammed script (non-Linux feature)
* -t timeout
* -v verbose mode
*/
int numarg;
int ret = 0;
int i;
DEBUGASSERT(priv != NULL);
if (priv->argc < 2)
{
ret = -EINVAL;
}
/* Iterate through command-line arguments and parse those */
for (i = 1; !ret && i < priv->argc && priv->argv[i]; i++)
{
if (priv->argv[i][0] != '-')
{
ret = -EINVAL;
}
else
{
switch (priv->argv[i][1])
{
case 'd':
/* set the TTY device node */
strncpy(priv->tty,
(FAR char*) priv->argv[i] + 2,
CHAT_TTYNAME_SIZE-1);
break;
case 'e':
priv->ctl.echo = true;
break;
case 'f':
ret = chat_script_read(priv,
(FAR char*) priv->argv[i] + 2);
break;
case 'p':
numarg = strtol((FAR char*) priv->argv[i] + 2,
NULL, 10);
if (errno < 0)
{
ret = -EINVAL;
break;
}
ret = chat_script_preset(priv, numarg);
break;
case 't':
numarg = strtol((FAR char*) priv->argv[i] + 2,
NULL, 10);
if (errno < 0 || numarg < 0)
{
ret = -EINVAL;
}
else
{
priv->ctl.timeout = numarg;
}
break;
case 'v':
priv->ctl.verbose = true;
break;
default:
ret = -EINVAL;
break;
}
}
}
return ret;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: chat_main
*
* Description:
* Chat command entry point.
*
****************************************************************************/
#ifdef CONFIG_BUILD_KERNEL
int main(int argc, FAR char** argv)
#else
int chat_main(int argc, FAR char** argv)
#endif
{
struct chat_app priv;
int ret;
int exit_code = EXIT_SUCCESS;
priv.argc = argc;
priv.argv = argv;
priv.ctl.echo = false;
priv.ctl.verbose = false;
priv.ctl.timeout = CONFIG_EXAMPLES_CHAT_TIMEOUT_SECONDS;
priv.script = NULL;
priv.script_dynalloc = false;
strncpy(priv.tty, CONFIG_EXAMPLES_CHAT_TTY_DEVNODE, CHAT_TTYNAME_SIZE-1);
vdbg("parsing the arguments\n");
ret = chat_parse_args((FAR struct chat_app*) &priv);
if (ret < 0)
{
vdbg("Command line parsing failed: code %d, errno %d\n", ret, errno);
chat_show_usage();
exit_code = EXIT_FAILURE;
goto with_script;
}
if (priv.script == NULL)
{
fprintf(stderr, "No chat script given\n");
exit_code = EXIT_FAILURE;
goto no_script;
}
vdbg("opening %s\n", priv.tty);
priv.ctl.fd = open(priv.tty, O_RDWR);
if (priv.ctl.fd < 0)
{
vdbg("Failed to open %s: %d\n", priv.tty, errno);
exit_code = EXIT_FAILURE;
goto with_script;
}
vdbg("setting up character device\n");
ret = chat_chardev(&priv);
if (ret < 0)
{
vdbg("Failed to open %s: %d\n", priv.tty, errno);
exit_code = EXIT_FAILURE;
goto with_tty_dev;
}
ret = chat((FAR struct chat_ctl*) &priv.ctl, priv.script);
with_tty_dev:
close(priv.ctl.fd);
with_script:
if (priv.script_dynalloc)
{
free(priv.script);
}
no_script:
fflush(stderr);
fflush(stdout);
vdbg("Exit code %d\n", exit_code);
return exit_code;
}

40
examples/pppd/pppd_main.c
View File

@ -50,27 +50,17 @@
* Private Data
****************************************************************************/
static struct chat_script_s connect_script =
{
.timeout = 30,
.lines =
{
{"AT", "OK"},
{"AT+CGDCONT = 1,\"IP\",\"internet\"", "OK"},
{"ATD*99***1#", "CONNECT"},
{0, 0}
},
};
static FAR char connect_script[] =
"ECHO ON "
"TIMEOUT 30 "
"\"\" ATE1 "
"OK AT+CGDCONT=1,\\\"IP\\\",\\\"internet\\\" "
"OK ATD*99***1# "
"CONNECT \\c";
static struct chat_script_s disconnect_script =
{
.timeout = 30,
.lines =
{
{"ATZ", "OK"},
{0, 0}
},
};
static FAR char disconnect_script[] =
"\"\" ATZ "
"OK \\c";
/****************************************************************************
* Public Functions
@ -84,12 +74,12 @@ int pppd_main(int argc, char *argv[])
{
struct pppd_settings_s pppd_settings =
{
.disconnect_script = &disconnect_script,
.connect_script = &connect_script,
.ttyname = "/dev/ttyS2",
.disconnect_script = disconnect_script,
.connect_script = connect_script,
.ttyname = "/dev/ttyS1",
#ifdef CONFIG_NETUTILS_PPPD_PAP
.pap_username = "username",
.pap_password = "password",
.pap_username = "user",
.pap_password = "pass",
#endif
};

26
netutils/pppd/chat.h → include/netutils/chat.h
View File

@ -1,8 +1,8 @@
/****************************************************************************
* netutils/pppd/chat.h
* apps/include/netutils/chat.h
*
* Copyright (C) 2015 Max Nekludov. All rights reserved.
* Author: Max Nekludov <macscomp@gmail.com>
* Copyright (C) 2016 Vladimir Komendantskiy. All rights reserved.
* Author: Vladimir Komendantskiy <vladimir@moixaenergy.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@ -33,19 +33,29 @@
*
****************************************************************************/
#ifndef __APPS_NETUTILS_PPPD_CHAT_H
#define __APPS_NETUTILS_PPPD_CHAT_H
#ifndef __APPS_INCLUDE_NETUTILS_CHAT_H
#define __APPS_INCLUDE_NETUTILS_CHAT_H
/****************************************************************************
* Included Files
****************************************************************************/
#include <apps/netutils/pppd.h>
#include <stdbool.h>
/****************************************************************************
* Public Types
****************************************************************************/
/* Type of chat control parameters. */
struct chat_ctl
{
int fd; /* TTY file descriptor */
bool echo; /* echo modem output to stderr */
bool verbose; /* print script lines to stderr */
int timeout; /* expected response timeout */
};
/****************************************************************************
* Public Function Prototypes
****************************************************************************/
@ -59,11 +69,11 @@ extern "C"
#define EXTERN extern
#endif
int ppp_chat(int fd, struct chat_script_s *script, int echo);
int chat(FAR struct chat_ctl* ctl, FAR char* script);
#undef EXTERN
#ifdef __cplusplus
}
#endif
#endif /* __APPS_NETUTILS_PPPD_CHAT_H */
#endif /* __APPS_INCLUDE_NETUTILS_CHAT_H */

16
include/netutils/pppd.h
View File

@ -61,18 +61,6 @@
* Public Types
****************************************************************************/
struct chat_line_s
{
const char *request;
const char *response;
};
struct chat_script_s
{
time_t timeout;
struct chat_line_s lines[];
};
struct pppd_settings_s
{
/* Serial Interface */
@ -88,8 +76,8 @@ struct pppd_settings_s
/* Chat Scripts */
struct chat_script_s *connect_script;
struct chat_script_s *disconnect_script;
FAR char* connect_script;
FAR char* disconnect_script;
};
/****************************************************************************

1
netutils/Kconfig
View File

@ -5,6 +5,7 @@
menu "Network Utilities"
source "$APPSDIR/netutils/chat/Kconfig"
source "$APPSDIR/netutils/codecs/Kconfig"
source "$APPSDIR/netutils/dhcpc/Kconfig"
source "$APPSDIR/netutils/dhcpd/Kconfig"

4
netutils/Make.defs
View File

@ -34,6 +34,10 @@
#
############################################################################
ifeq ($(CONFIG_NETUTILS_CHAT),y)
CONFIGURED_APPS += netutils/chat
endif
ifeq ($(CONFIG_NETUTILS_CODECS),y)
CONFIGURED_APPS += netutils/codecs
endif

2
netutils/Makefile
View File

@ -37,7 +37,7 @@
# Sub-directories
SUBDIRS = json codecs
SUBDIRS = chat json codecs
ifeq ($(CONFIG_NET),y)
SUBDIRS += netlib dhcpc dhcpd discover ftpc ftpd smtp telnetd
SUBDIRS += webclient webserver tftpc thttpd xmlrpc pppd

15
netutils/chat/Kconfig Normal file
View File

@ -0,0 +1,15 @@
#
# For a description of the syntax of this configuration file,
# see the file kconfig-language.txt in the NuttX tools repository.
#
config NETUTILS_CHAT
bool "Chat tool"
default n
depends on !DISABLE_POLL
---help---
Enable the chat tool.
if NETUTILS_CHAT
endif # NETUTILS_CHAT

98
netutils/chat/Makefile Normal file
View File

@ -0,0 +1,98 @@
############################################################################
# apps/netutils/chat/Makefile
#
# Copyright (C) 2016 Vladimir Komendantskiy. All rights reserved.
# Author: Vladimir Komendantskiy <vladimir@moixaenergy.com>
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# 3. Neither the name NuttX nor the names of its contributors may be
# used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
############################################################################
-include $(TOPDIR)/.config
-include $(TOPDIR)/Make.defs
include $(APPDIR)/Make.defs
ASRCS =
CSRCS =
CSRCS += chat.c
AOBJS = $(ASRCS:.S=$(OBJEXT))
COBJS = $(CSRCS:.c=$(OBJEXT))
SRCS = $(ASRCS) $(CSRCS)
OBJS = $(AOBJS) $(COBJS)
ifeq ($(CONFIG_WINDOWS_NATIVE),y)
BIN = ..\..\libapps$(LIBEXT)
else
ifeq ($(WINTOOL),y)
BIN = ..\\..\\libapps$(LIBEXT)
else
BIN = ../../libapps$(LIBEXT)
endif
endif
ROOTDEPPATH = --dep-path .
# Common build
VPATH =
all: .built
.PHONY: context depend clean distclean
$(AOBJS): %$(OBJEXT): %.S
$(call ASSEMBLE, $<, $@)
$(COBJS): %$(OBJEXT): %.c
$(call COMPILE, $<, $@)
.built: $(OBJS)
$(call ARCHIVE, $(BIN), $(OBJS))
$(Q) touch .built
install:
context:
.depend: Makefile $(SRCS)
$(Q) $(MKDEP) $(ROOTDEPPATH) "$(CC)" -- $(CFLAGS) -- $(SRCS) >Make.dep
$(Q) touch $@
depend: .depend
clean:
$(call DELFILE, .built)
$(call CLEAN)
distclean: clean
$(call DELFILE, Make.dep)
$(call DELFILE, .depend)
-include Make.dep

730
netutils/chat/chat.c Normal file
View File

@ -0,0 +1,730 @@
/****************************************************************************
* apps/netutils/chat/chat.c
*
* Copyright (C) 2016 Vladimir Komendantskiy. All rights reserved.
* Author: Vladimir Komendantskiy <vladimir@moixaenergy.com>
* Partly based on code by Max Nekludov <macscomp@gmail.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "chat.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define CHAT_TOKEN_SIZE 128
/****************************************************************************
* Pivate types
****************************************************************************/
/* Type of singly-linked list of tokens */
struct chat_token
{
FAR char* string;
bool no_termin;
FAR struct chat_token* next;
};
/****************************************************************************
* Private Functions
****************************************************************************/
void chat_init(FAR struct chat* priv, FAR struct chat_ctl* ctl)
{
DEBUGASSERT(priv != NULL && ctl != NULL && ctl->timeout >= 0);
memcpy(&priv->ctl, ctl, sizeof(struct chat_ctl));
priv->script = NULL;
}
/* Linear one-pass tokenizer. */
static int chat_tokenise(FAR struct chat* priv,
FAR char* script,
FAR struct chat_token** first_tok)
{
FAR char *cursor = script; /* pointer to the current character */
unsigned int quoted = 0; /* two-valued:
* 1: quoted (expecting a closing quote)
* 0: not quoted */
unsigned int escaped = 0; /* two-valued */
char tok_str[CHAT_TOKEN_SIZE]; /* current token buffer */
int tok_pos = 0; /* current length of the current token */
FAR struct chat_token *tok = NULL; /* the last complete token */
bool no_termin; /* line termination property:
* true iff line terminator is deasserted */
int ret = 0;
/* Delimiter handler */
int tok_on_delimiter(void)
{
if (!tok_pos && !quoted && !no_termin)
{
/* a) the first character in the script is a delimiter or
* b) the previous character was a delimiter,
* and in both cases it is not the empty string token,
* hence skipping.
*/
return 0;
}
/* Terminate the temporary */
tok_str[tok_pos] = '\0';
if (tok)
{
tok->next = malloc(sizeof(struct chat_token));
/* The terminated token becomes previous */
tok = tok->next;
}
else
{
/* There was no previous token */
*first_tok = malloc(sizeof(struct chat_token));
tok = *first_tok;
}
if (!tok)
{
/* out of memory */
return -ENOMEM;
}
/* Copy the temporary */
tok->string = strdup(tok_str);
tok->no_termin = no_termin;
/* Initialize the next token */
tok->next = NULL;
/* Reset the buffer position */
tok_pos = 0;
vdbg("%s (%d)\n", tok->string, tok->no_termin);
return 0;
}
/* Tokenizer start */
DEBUGASSERT(script != NULL);
vdbg("%s\n", script);
while (!ret && *cursor != '\0')
{
/* Assert line terminator */
no_termin = false;
switch (*cursor)
{
case '\\':
if (!quoted)
{
if (escaped)
{
tok_str[tok_pos++] = '\\';
}
escaped ^= 1;
}
else
{
/* Quoted */
tok_str[tok_pos++] = '\\';
}
break;
case '"':
if (escaped)
{
tok_str[tok_pos++] = '"';
escaped = 0;
}
else
{
/* Not escaped */
if (quoted && !tok_pos)
{
/* Empty string token */
ret = tok_on_delimiter();
}
quoted ^= 1;
/* No effect on the position in the temporary */
}
break;
case ' ':
case '\n':
case '\r':
case '\t':
if (quoted)
{
/* Append the quoted character to the temporary */
tok_str[tok_pos++] = *cursor;
}
else
{
ret = tok_on_delimiter();
}
break;
default:
if (escaped)
{
switch (*cursor)
{
case 'n':
tok_str[tok_pos++] = '\n';
break;
case 'r':
tok_str[tok_pos++] = '\r';
break;
case 'c':
/* Deassert line terminator */
no_termin = true;
break;
default:
ret = -EINVAL;
break;
}
escaped = 0;
}
else
{
/* Append the regular character to the temporary */
tok_str[tok_pos++] = *cursor;
}
break;
}
/* Shift the cursor right through the input string */
cursor++;
}
if (!ret && *cursor == '\0')
{
/* Treat the null terminator as an EOF delimiter */
ret = tok_on_delimiter();
}
vdbg("result %d\n", ret);
return ret;
}
/* Creates the internal representation of a tokenised chat script. */
static int chat_internalise(FAR struct chat* priv,
FAR struct chat_token* tok)
{
unsigned int rhs = 0; /* 1 iff processing the right-hand side,
* 0 otherwise */
FAR struct chat_line* line = NULL;
int len; /* length of the destination string when variable */
int ret = 0;
while (tok && !ret)
{
DEBUGASSERT(tok->string);
vdbg("(%c) %s\n", rhs ? 'R' : 'L', tok->string);
if (!rhs)
{
/* Create a new line */
if (!line)
{
/* First line */
line = malloc(sizeof(struct chat_line));
priv->script = line;
}
else
{
/* Subsequent line */
line->next = malloc(sizeof(struct chat_line));
line = line->next;
}
if (!line)
{
ret = -ENOMEM;
break;
}
line->next = NULL;
}
if (rhs)
{
len = strlen(tok->string);
if (!tok->no_termin)
{
/* Add space for the line terminator */
len += 2;
}
line->rhs = malloc(len + 1);
if (line->rhs)
{
/* Copy the token and add the line terminator as appropriate */
sprintf(line->rhs, tok->no_termin ? "%s" : "%s\r\n", tok->string);
}
else
{
ret = -ENOMEM;
}
}
else
{
if (!strcmp(tok->string, "ABORT"))
{
line->type = CHAT_LINE_TYPE_COMMAND;
line->lhs.command = CHAT_COMMAND_ABORT;
}
else if (!strcmp(tok->string, "ECHO"))
{
line->type = CHAT_LINE_TYPE_COMMAND;
line->lhs.command = CHAT_COMMAND_ECHO;
}
else if (!strcmp(tok->string, "PAUSE"))
{
line->type = CHAT_LINE_TYPE_COMMAND;
line->lhs.command = CHAT_COMMAND_PAUSE;
}
else if (!strcmp(tok->string, "SAY"))
{
line->type = CHAT_LINE_TYPE_COMMAND;
line->lhs.command = CHAT_COMMAND_SAY;
}
else if (!strcmp(tok->string, "TIMEOUT"))
{
line->type = CHAT_LINE_TYPE_COMMAND;
line->lhs.command = CHAT_COMMAND_TIMEOUT;
}
else
{
/* Not a command, hence an expectation */
line->type = CHAT_LINE_TYPE_EXPECT_SEND;
line->lhs.expect = strdup(tok->string);
if (!line->lhs.expect)
{
ret = -ENOMEM;
}
}
/* Initialise the rhs - for 'free' in case of error */
line->rhs = NULL;
}
/* Alternate between left-hand side and right-hand side */
rhs ^= 1;
tok = tok->next;
}
if (!ret && rhs)
{
/* The right-hand side of a line is missing */
ret = -ENODATA;
}
vdbg("result %d, rhs %d\n", ret, rhs);
return ret;
}
/* Chat token list deallocator */
static void chat_tokens_free(FAR struct chat_token* first_tok)
{
FAR struct chat_token* next_tok;
while (first_tok)
{
next_tok = first_tok->next;
DEBUGASSERT(first_tok->string != NULL);
free(first_tok->string);
free(first_tok);
first_tok = next_tok;
}
vdbg("tokens freed\n");
}
/* Main parsing function. */
static int chat_script_parse(FAR struct chat* priv, FAR char* script)
{
FAR struct chat_token* first_tok;
int ret;
ret = chat_tokenise(priv, script, &first_tok);
if (!ret)
{
ret = chat_internalise(priv, first_tok);
}
chat_tokens_free(first_tok);
return ret;
}
/* Polls the file descriptor for a specified number of milliseconds and, on
* successful read, stores 1 read byte at location pointed by 'c'. Otherwise
* returns a negative error code.
*/
static int chat_readb(FAR struct chat* priv, FAR char* c, int timeout_ms)
{
struct pollfd fds;
int ret;
fds.fd = priv->ctl.fd;
fds.events = POLLIN;
fds.revents = 0;
ret = poll(&fds, 1, timeout_ms);
if (ret <= 0)
{
vdbg("poll timed out\n");
return -ETIMEDOUT;
}
ret = read(priv->ctl.fd, c, 1);
if (ret != 1)
{
vdbg("read failed\n");
return -EPERM;
}
if (priv->ctl.echo)
{
fputc(*c, stderr);
}
vdbg("read \'%c\' (0x%02X)\n", *c, *c);
return 0;
}
static void chat_flush(FAR struct chat* priv)
{
char c;
vdbg("starting\n");
while (chat_readb(priv, (FAR char*) &c, 0) == 0);
vdbg("done\n");
}
static int chat_expect(FAR struct chat* priv, FAR const char* s)
{
char c;
struct timespec abstime;
struct timespec endtime;
int timeout_ms;
int s_len = strlen(s);
int i_match = 0; /* index of the next character to be matched in s */
int ret = 0;
/* Get initial time and set the end time */
clock_gettime(CLOCK_REALTIME, (FAR struct timespec*) &abstime);
endtime.tv_sec = abstime.tv_sec + priv->ctl.timeout;
endtime.tv_nsec = abstime.tv_nsec;
while (!ret && i_match < s_len &&
(abstime.tv_sec < endtime.tv_sec ||
(abstime.tv_sec == endtime.tv_sec &&
abstime.tv_nsec < endtime.tv_nsec)))
{
timeout_ms =
(endtime.tv_sec - abstime.tv_sec) * 1000 +
(endtime.tv_nsec - abstime.tv_nsec) / 1000000;
DEBUGASSERT(timeout_ms >= 0);
ret = chat_readb(priv, &c, timeout_ms);
if (!ret)
{
if (c == s[i_match])
{
/* Continue matching the next character */
i_match++;
}
else
{
/* Match failed; start anew */
i_match = 0;
}
/* Update current time */
clock_gettime(CLOCK_REALTIME, (FAR struct timespec*) &abstime);
}
}
vdbg("result %d\n", ret);
return ret;
}
static int chat_send(FAR struct chat* priv, FAR const char* s)
{
int ret = 0;
int len = strlen(s);
/* 'write' returns the number of successfully written characters */
ret = write(priv->ctl.fd, s, len);
vdbg("wrote %d out of %d bytes of \'%s\'\n", ret, len, s);
if (ret > 0)
{
/* Just SUCCESS */
ret = 0;
}
return ret;
}
static int chat_line_run(FAR struct chat* priv,
FAR const struct chat_line* line)
{
int ret = 0;
int numarg;
vdbg("type %d, rhs %s\n", line->type, line->rhs);
switch (line->type)
{
case CHAT_LINE_TYPE_COMMAND:
if (priv->ctl.verbose)
{
fprintf(stderr, "chat: cmd %d, arg %s\n",
line->lhs.command, line->rhs);
}
switch (line->lhs.command)
{
case CHAT_COMMAND_ABORT:
/* TODO */
break;
case CHAT_COMMAND_ECHO:
if (strcmp(line->rhs, "ON"))
{
priv->ctl.echo = true;
}
else
{
priv->ctl.echo = false;
}
break;
case CHAT_COMMAND_PAUSE:
numarg = atoi(line->rhs);
if (numarg < 0)
{
numarg = 0;
}
sleep(numarg);
break;
case CHAT_COMMAND_SAY:
fprintf(stderr, "%s\n", line->rhs);
break;
case CHAT_COMMAND_TIMEOUT:
numarg = atoi(line->rhs);
if (numarg < 0)
{
vdbg("invalid timeout string %s\n", line->rhs);
}
else
{
vdbg("timeout is %d s\n", numarg);
priv->ctl.timeout = numarg;
}
break;
default:
break;
}
break;
case CHAT_LINE_TYPE_EXPECT_SEND:
if (priv->ctl.verbose)
{
fprintf(stderr, "chat: %s %s\n", line->lhs.expect, line->rhs);
}
ret = chat_expect(priv, line->lhs.expect);
if (!ret)
{
/* Discard anything after the confirmed expectation */
chat_flush(priv);
ret = chat_send(priv, line->rhs);
}
break;
default:
ret = -EINVAL;
break;
}
return ret;
}
static int chat_script_run(FAR struct chat* priv)
{
FAR struct chat_line* line = priv->script;
int ret = 0;
#ifdef CONFIG_DEBUG_VERBOSE
int line_num = 0;
#endif
while (!ret && line)
{
ret = chat_line_run(priv, line);
if (!ret)
{
line = line->next;
#ifdef CONFIG_DEBUG_VERBOSE
line_num++;
#endif
}
}
vdbg("Script result %d, exited on line %d\n", ret, line_num);
return ret;
}
static int chat_script_free(FAR struct chat* priv)
{
FAR struct chat_line* line = priv->script;
FAR struct chat_line* next_line;
int ret = 0;
while (line)
{
next_line = line->next;
if (line->type == CHAT_LINE_TYPE_EXPECT_SEND)
{
free(line->lhs.expect);
}
free(line->rhs);
free(line);
line = next_line;
}
priv->script = NULL;
return ret;
}
/****************************************************************************
* Public Functions
****************************************************************************/
int chat(FAR struct chat_ctl* ctl, FAR char* script)
{
int ret = 0;
struct chat priv;
DEBUGASSERT(script != NULL);
chat_init(&priv, ctl);
ret = chat_script_parse(&priv, script);
if (!ret)
{
/* TODO: optionally, free 'script' here */
ret = chat_script_run(&priv);
}
chat_script_free(&priv);
return ret;
}

96
netutils/chat/chat.h Normal file
View File

@ -0,0 +1,96 @@
/****************************************************************************
* apps/netutils/chat/chat.h
*
* Copyright (C) 2016 Vladimir Komendantskiy. All rights reserved.
* Author: Vladimir Komendantskiy <vladimir@moixaenergy.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
#ifndef __APPS_NETUTILS_CHAT_CHAT_H
#define __APPS_NETUTILS_CHAT_CHAT_H
/****************************************************************************
* Included Files
****************************************************************************/
#include <apps/netutils/chat.h>
/****************************************************************************
* Public Types
****************************************************************************/
enum chat_line_type
{
CHAT_LINE_TYPE_COMMAND = 0,
CHAT_LINE_TYPE_EXPECT_SEND,
};
enum chat_command
{
CHAT_COMMAND_ABORT = 0,
CHAT_COMMAND_ECHO,
CHAT_COMMAND_PAUSE,
CHAT_COMMAND_SAY,
CHAT_COMMAND_TIMEOUT,
};
/* Type of chat script: singly-linked list of chat lines. */
struct chat_line
{
enum chat_line_type type;
union
{
/* type-0 chat line command */
enum chat_command command;
/* type-1 chat line expected string */
FAR char* expect;
} lhs;
/* type 0: command argument
* type 1: string to be sent
*/
FAR char* rhs;
FAR struct chat_line* next; /* pointer to the next line in the script */
};
/* Chat private state. */
struct chat
{
struct chat_ctl ctl; /* Embedded 'chat_ctl' type. */
FAR struct chat_line* script; /* first line of the script */
};
#endif /* __APPS_NETUTILS_CHAT_CHAT_H */

1
netutils/pppd/Kconfig
View File

@ -6,6 +6,7 @@
config NETUTILS_PPPD
bool "PPP daemon"
default n
select NETUTILS_CHAT
select NET_TUN
depends on NET && NET_UDP
---help---

2
netutils/pppd/Makefile
View File

@ -40,7 +40,7 @@ include $(APPDIR)/Make.defs
ASRCS =
CSRCS =
CSRCS += pppd.c chat.c ppp.c ahdlc.c lcp.c ipcp.c
CSRCS += pppd.c ppp.c ahdlc.c lcp.c ipcp.c
ifeq ($(CONFIG_NETUTILS_PPPD_PAP),y)
CSRCS += pap.c
endif

207
netutils/pppd/chat.c
View File

@ -1,207 +0,0 @@
/****************************************************************************
* netutils/pppd/chat.c
*
* Copyright (C) 2015 Max Nekludov. All rights reserved.
* Author: Max Nekludov <macscomp@gmail.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include "ppp_conf.h"
#include "ppp_arch.h"
#include "chat.h"
#include <poll.h>
#include <apps/netutils/pppd.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define CHAT_MAX_SKIP 8
#define CHAT_ECHO_TIMEOUT 500
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: chat_read_byte
****************************************************************************/
static int chat_read_byte(int fd, char* c, int timeout)
{
int ret;
struct pollfd fds;
fds.fd = fd;
fds.events = POLLIN;
fds.revents = 0;
ret = poll(&fds, 1, timeout);
if (ret <= 0)
{
return -1;
}
ret = read(fd, c, 1);
if (ret != 1)
{
return -1;
}
printf("chat: char = %c (0x%02X)\n", *c, *c);
return 0;
}
/****************************************************************************
* Name: chat_flush
****************************************************************************/
static void chat_flush(int fd)
{
char tmp;
while (chat_read_byte(fd, &tmp, 0) == 0);
}
/****************************************************************************
* Name: chat_check_response
****************************************************************************/
static int chat_check_response(int fd, const char* response, int timeout)
{
char c;
int ret;
int skip = CHAT_MAX_SKIP;
while (*response)
{
ret = chat_read_byte(fd, &c, timeout);
if (ret < 0)
{
return ret;
}
if (skip > 0 && (c == '\r' || c == '\n'))
{
--skip;
continue;
}
if (c == *response)
{
++response;
}
else
{
return -1;
}
}
return 0;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: ppp_chat
****************************************************************************/
int ppp_chat(int fd, struct chat_script_s *script, int echo)
{
int ret;
size_t len;
struct chat_line_s *line = script->lines;
const char* request = line->request;
const char* response = line->response;
while (request)
{
chat_flush(fd);
printf("chat: send '%s`\n", request);
len = strlen(request);
ret = write(fd, request, len);
if (ret < 0)
{
return ret;
}
else if ((size_t)ret != len)
{
return -1;
}
ret = write(fd, "\r\n", 2);
if (ret != 2)
{
return -1;
}
/* Check echo if enabled */
if (echo)
{
ret = chat_check_response(fd, request, CHAT_ECHO_TIMEOUT);
if (ret < 0)
{
printf("chat: invalid echo\n");
return ret;
}
}
if (response)
{
printf("chat: wait for '%s`\n", response);
ret = chat_check_response(fd, response, script->timeout * 1000);
if (ret < 0)
{
printf("chat: bad response\n");
return ret;
}
printf("chat: got it!\n");
}
++line;
request = line->request;
response = line->response;
}
return 0;
}

12
netutils/pppd/ppp.h
View File

@ -47,6 +47,8 @@
#include <nuttx/config.h>
#include <apps/netutils/chat.h>
#include "ppp_conf.h"
#include "ahdlc.h"
#include "lcp.h"
@ -128,7 +130,6 @@ struct ppp_context_s
/* Interfaces */
int tty_fd;
int if_fd;
u8_t ifname[IFNAMSIZ];
@ -175,11 +176,6 @@ struct ppp_context_s
u8_t ahdlc_flags; /* ahdlc state flags, see above */
u8_t ahdlc_tx_offline;
/* Scripts */
struct chat_script_s *connect_script;
struct chat_script_s *disconnect_script;
/* Statistics counters */
#ifdef PPP_STATISTICS
@ -189,6 +185,10 @@ struct ppp_context_s
u32_t ppp_tx_frame_count;
#endif
/* Chat controls */
struct chat_ctl ctl;
/* PPPD Settings */
struct pppd_settings_s *settings;

29
netutils/pppd/pppd.c
View File

@ -58,8 +58,8 @@
#include <nuttx/net/tun.h>
#include "ppp.h"
#include "chat.h"
#include <apps/netutils/chat.h>
#include <apps/netutils/pppd.h>
#if PPP_ARCH_HAVE_MODEM_RESET
@ -218,13 +218,13 @@ void ppp_reconnect(struct ppp_context_s *ctx)
sleep(1);
lcp_disconnect(ctx, ++ctx->ppp_id);
sleep(1);
write(ctx->tty_fd, "+++", 3);
write(ctx->ctl.fd, "+++", 3);
sleep(2);
write(ctx->tty_fd, "ATE1\r\n", 6);
write(ctx->ctl.fd, "ATE1\r\n", 6);
if (pppd_settings->disconnect_script)
{
ret = ppp_chat(ctx->tty_fd, pppd_settings->disconnect_script, 1 /*echo on*/);
ret = chat(&ctx->ctl, pppd_settings->disconnect_script);
if (ret < 0)
{
printf("ppp: disconnect script failed\n");
@ -235,7 +235,7 @@ void ppp_reconnect(struct ppp_context_s *ctx)
{
do
{
ret = ppp_chat(ctx->tty_fd, pppd_settings->connect_script, 1 /*echo on*/);
ret = chat(&ctx->ctl, pppd_settings->connect_script);
if (ret < 0)
{
printf("ppp: connect script failed\n");
@ -286,7 +286,7 @@ time_t ppp_arch_clock_seconds(void)
int ppp_arch_getchar(struct ppp_context_s *ctx, u8_t *c)
{
int ret;
ret = read(ctx->tty_fd, c, 1);
ret = read(ctx->ctl.fd, c, 1);
return ret == 1 ? ret : 0;
}
@ -299,17 +299,17 @@ int ppp_arch_putchar(struct ppp_context_s *ctx, u8_t c)
int ret;
struct pollfd fds;
ret = write(ctx->tty_fd, &c, 1);
ret = write(ctx->ctl.fd, &c, 1);
if (ret < 0 && errno == EAGAIN)
{
fds.fd = ctx->tty_fd;
fds.fd = ctx->ctl.fd;
fds.events = POLLOUT;
fds.revents = 0;
ret = poll(&fds, 1, 1000);
if (ret > 0)
{
ret = write(ctx->tty_fd, &c, 1);
ret = write(ctx->ctl.fd, &c, 1);
}
}
@ -338,18 +338,21 @@ int pppd(struct pppd_settings_s *pppd_settings)
return 2;
}
ctx->tty_fd = open_tty(pppd_settings->ttyname);
if (ctx->tty_fd < 0)
ctx->ctl.fd = open_tty(pppd_settings->ttyname);
if (ctx->ctl.fd < 0)
{
close(ctx->tty_fd);
close(ctx->ctl.fd);
free(ctx);
return 2;
}
ctx->ctl.echo = true;
ctx->ctl.verbose = true;
ctx->ctl.timeout = 30;
fds[0].fd = ctx->if_fd;
fds[0].events = POLLIN;
fds[1].fd = ctx->tty_fd;
fds[1].fd = ctx->ctl.fd;
fds[1].events = POLLIN;
ppp_init(ctx);