513 lines
13 KiB
C
513 lines
13 KiB
C
/*
|
|
*
|
|
Copyright (C) 2009-2016 Olof Hagsand and Benny Holmgren
|
|
|
|
This file is part of CLIXON.
|
|
|
|
CLIXON is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
CLIXON is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with CLIXON; see the file LICENSE. If not, see
|
|
<http://www.gnu.org/licenses/>.
|
|
|
|
*
|
|
* Protocol to communicate between clients (eg clicon_cli, clicon_netconf)
|
|
* and server (clicon_backend)
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "clixon_config.h" /* generated by config & autoconf */
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stdarg.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include <syslog.h>
|
|
#include <signal.h>
|
|
#include <ctype.h>
|
|
#include <sys/types.h>
|
|
#include <sys/time.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/stat.h>
|
|
#include <netinet/in.h>
|
|
#include <sys/un.h>
|
|
#include <arpa/inet.h>
|
|
|
|
/* cligen */
|
|
#include <cligen/cligen.h>
|
|
|
|
/* clicon */
|
|
#include "clixon_err.h"
|
|
#include "clixon_log.h"
|
|
#include "clixon_queue.h"
|
|
#include "clixon_chunk.h"
|
|
#include "clixon_sig.h"
|
|
#include "clixon_proto.h"
|
|
#include "clixon_proto_encode.h"
|
|
|
|
static int _atomicio_sig = 0;
|
|
|
|
struct map_type2str{
|
|
enum clicon_msg_type mt_type;
|
|
char *mt_str; /* string as in 4.2.4 in RFC 6020 */
|
|
};
|
|
|
|
/* Mapping between yang keyword string <--> clicon constants */
|
|
static const struct map_type2str msgmap[] = {
|
|
{CLICON_MSG_COMMIT, "commit"},
|
|
{CLICON_MSG_VALIDATE, "validate"},
|
|
{CLICON_MSG_CHANGE, "change"},
|
|
{CLICON_MSG_SAVE, "save"},
|
|
{CLICON_MSG_LOAD, "load"},
|
|
{CLICON_MSG_KILL, "kill"},
|
|
{CLICON_MSG_DEBUG, "debug"},
|
|
{CLICON_MSG_CALL, "call"},
|
|
{CLICON_MSG_SUBSCRIPTION, "subscription"},
|
|
{CLICON_MSG_OK, "ok"},
|
|
{CLICON_MSG_NOTIFY, "notify"},
|
|
{CLICON_MSG_ERR, "err"},
|
|
{-1, NULL},
|
|
};
|
|
|
|
static char *
|
|
msg_type2str(enum clicon_msg_type type)
|
|
{
|
|
const struct map_type2str *mt;
|
|
|
|
for (mt = &msgmap[0]; mt->mt_str; mt++)
|
|
if (mt->mt_type == type)
|
|
return mt->mt_str;
|
|
return NULL;
|
|
}
|
|
|
|
/*! Open local connection using unix domain sockets
|
|
*/
|
|
int
|
|
clicon_connect_unix(char *sockpath)
|
|
{
|
|
struct sockaddr_un addr;
|
|
int retval = -1;
|
|
int s;
|
|
|
|
if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
|
|
clicon_err(OE_CFG, errno, "socket");
|
|
return -1;
|
|
}
|
|
memset(&addr, 0, sizeof(addr));
|
|
addr.sun_family = AF_UNIX;
|
|
strncpy(addr.sun_path, sockpath, sizeof(addr.sun_path)-1);
|
|
|
|
clicon_debug(2, "%s: connecting to %s", __FUNCTION__, addr.sun_path);
|
|
if (connect(s, (struct sockaddr *)&addr, SUN_LEN(&addr)) < 0){
|
|
if (errno == EACCES)
|
|
clicon_err(OE_CFG, errno, "connecting unix socket: %s.\n"
|
|
"Client should be member of group $CLICON_SOCK_GROUP: ",
|
|
sockpath);
|
|
else
|
|
clicon_err(OE_CFG, errno, "connecting unix socket: %s", sockpath);
|
|
close(s);
|
|
goto done;
|
|
}
|
|
retval = s;
|
|
done:
|
|
return retval;
|
|
}
|
|
|
|
static void
|
|
atomicio_sig_handler(int arg)
|
|
{
|
|
_atomicio_sig++;
|
|
}
|
|
|
|
|
|
/*! Ensure all of data on socket comes through. fn is either read or write
|
|
*/
|
|
static ssize_t
|
|
atomicio(ssize_t (*fn) (int, void *, size_t), int fd, void *_s, size_t n)
|
|
{
|
|
char *s = _s;
|
|
ssize_t res, pos = 0;
|
|
|
|
while (n > pos) {
|
|
_atomicio_sig = 0;
|
|
res = (fn)(fd, s + pos, n - pos);
|
|
switch (res) {
|
|
case -1:
|
|
if (errno == EINTR){
|
|
if (!_atomicio_sig)
|
|
continue;
|
|
}
|
|
else
|
|
if (errno == EAGAIN)
|
|
continue;
|
|
case 0: /* fall thru */
|
|
return (res);
|
|
default:
|
|
pos += res;
|
|
}
|
|
}
|
|
return (pos);
|
|
}
|
|
|
|
static int
|
|
msg_dump(struct clicon_msg *msg)
|
|
{
|
|
int i;
|
|
char buf[9*8];
|
|
char buf2[9*8];
|
|
|
|
memset(buf2, 0, sizeof(buf2));
|
|
snprintf(buf2, sizeof(buf2), "%s:", __FUNCTION__);
|
|
for (i=0; i<ntohs(msg->op_len); i++){
|
|
snprintf(buf, sizeof(buf), "%s%02x", buf2, ((char*)msg)[i]&0xff);
|
|
if ((i+1)%32==0){
|
|
clicon_debug(2, buf);
|
|
snprintf(buf, sizeof(buf), "%s:", __FUNCTION__);
|
|
}
|
|
else
|
|
if ((i+1)%4==0)
|
|
snprintf(buf, sizeof(buf), "%s ", buf2);
|
|
strncpy(buf2, buf, sizeof(buf2));
|
|
}
|
|
if (i%32)
|
|
clicon_debug(2, buf);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
clicon_msg_send(int s,
|
|
struct clicon_msg *msg)
|
|
{
|
|
int retval = -1;
|
|
|
|
clicon_debug(2, "%s: send msg seq=%d len=%d",
|
|
__FUNCTION__, ntohs(msg->op_type), ntohs(msg->op_len));
|
|
if (debug > 2)
|
|
msg_dump(msg);
|
|
if (atomicio((ssize_t (*)(int, void *, size_t))write,
|
|
s, msg, ntohs(msg->op_len)) < 0){
|
|
clicon_err(OE_CFG, errno, "%s", __FUNCTION__);
|
|
goto done;
|
|
}
|
|
retval = 0;
|
|
done:
|
|
return retval;
|
|
}
|
|
|
|
|
|
/*! Receive a CLICON message on a UNIX domain socket
|
|
*
|
|
* XXX: timeout? and signals?
|
|
* There is rudimentary code for turning on signals and handling them
|
|
* so that they can be interrupted by ^C. But the problem is that this
|
|
* is a library routine and such things should be set up in the cli
|
|
* application for example: a daemon calling this function will want another
|
|
* behaviour.
|
|
* Now, ^C will interrupt the whole process, and this may not be what you want.
|
|
*
|
|
* @param[in] s UNIX domain socket to communicate with backend
|
|
* @param[out] msg CLICON msg data reply structure. allocated using CLICON chunks,
|
|
* freed by caller with unchunk*(...,label)
|
|
* @param[out] eof Set if eof encountered
|
|
* @param[in] label Label used in chunk allocation and deallocation.
|
|
* Note: caller must ensure that s is closed if eof is set after call.
|
|
*/
|
|
int
|
|
clicon_msg_rcv(int s,
|
|
struct clicon_msg **msg,
|
|
int *eof,
|
|
const char *label)
|
|
{
|
|
int retval = -1;
|
|
struct clicon_msg hdr;
|
|
int hlen;
|
|
int len2;
|
|
sigfn_t oldhandler;
|
|
uint16_t mlen;
|
|
|
|
*eof = 0;
|
|
if (0)
|
|
set_signal(SIGINT, atomicio_sig_handler, &oldhandler);
|
|
|
|
if ((hlen = atomicio(read, s, &hdr, sizeof(hdr))) < 0){
|
|
clicon_err(OE_CFG, errno, "%s", __FUNCTION__);
|
|
goto done;
|
|
}
|
|
if (hlen == 0){
|
|
retval = 0;
|
|
*eof = 1;
|
|
goto done;
|
|
}
|
|
if (hlen != sizeof(hdr)){
|
|
clicon_err(OE_CFG, errno, "%s: header too short (%d)", __FUNCTION__, hlen);
|
|
goto done;
|
|
}
|
|
mlen = ntohs(hdr.op_len);
|
|
clicon_debug(2, "%s: rcv msg seq=%d, len=%d",
|
|
__FUNCTION__, ntohs(hdr.op_type), mlen);
|
|
if ((*msg = (struct clicon_msg *)chunk(mlen, label)) == NULL){
|
|
clicon_err(OE_CFG, errno, "%s: chunk", __FUNCTION__);
|
|
goto done;
|
|
}
|
|
memcpy(*msg, &hdr, hlen);
|
|
if ((len2 = read(s, (*msg)->op_body, mlen - sizeof(hdr))) < 0){
|
|
clicon_err(OE_CFG, errno, "%s: read", __FUNCTION__);
|
|
goto done;
|
|
}
|
|
if (len2 != mlen - sizeof(hdr)){
|
|
clicon_err(OE_CFG, errno, "%s: body too short", __FUNCTION__);
|
|
goto done;
|
|
}
|
|
if (debug > 1)
|
|
msg_dump(*msg);
|
|
retval = 0;
|
|
done:
|
|
if (0)
|
|
set_signal(SIGINT, oldhandler, NULL);
|
|
return retval;
|
|
}
|
|
|
|
|
|
/*! Connect to server, send an clicon_msg message and wait for result.
|
|
* Compared to clicon_rpc, this is a one-shot rpc: open, send, get reply and close.
|
|
* NOTE: this is dependent on unix domain
|
|
*/
|
|
int
|
|
clicon_rpc_connect_unix(struct clicon_msg *msg,
|
|
char *sockpath,
|
|
char **data,
|
|
uint16_t *datalen,
|
|
int *sock0,
|
|
const char *label)
|
|
{
|
|
int retval = -1;
|
|
int s = -1;
|
|
struct stat sb;
|
|
|
|
clicon_debug(1, "Send %s msg on %s",
|
|
msg_type2str(ntohs(msg->op_type)), sockpath);
|
|
/* special error handling to get understandable messages (otherwise ENOENT) */
|
|
if (stat(sockpath, &sb) < 0){
|
|
clicon_err(OE_PROTO, errno, "%s: config daemon not running?", sockpath);
|
|
goto done;
|
|
}
|
|
if (!S_ISSOCK(sb.st_mode)){
|
|
clicon_err(OE_PROTO, EIO, "%s: Not unix socket", sockpath);
|
|
goto done;
|
|
}
|
|
if ((s = clicon_connect_unix(sockpath)) < 0)
|
|
goto done;
|
|
if (clicon_rpc(s, msg, data, datalen, label) < 0)
|
|
goto done;
|
|
if (sock0 != NULL)
|
|
*sock0 = s;
|
|
retval = 0;
|
|
done:
|
|
if (sock0 == NULL && s >= 0)
|
|
close(s);
|
|
return retval;
|
|
}
|
|
|
|
/*! Connect to server, send an clicon_msg message and wait for result using an inet socket
|
|
* Compared to clicon_rpc, this is a one-shot rpc: open, send, get reply and close.
|
|
*/
|
|
int
|
|
clicon_rpc_connect_inet(struct clicon_msg *msg,
|
|
char *dst,
|
|
uint16_t port,
|
|
char **data,
|
|
uint16_t *datalen,
|
|
int *sock0,
|
|
const char *label)
|
|
{
|
|
int retval = -1;
|
|
int s = -1;
|
|
struct sockaddr_in addr;
|
|
|
|
clicon_debug(1, "Send %s msg to %s:%hu",
|
|
msg_type2str(ntohs(msg->op_type)), dst, port);
|
|
|
|
memset(&addr, 0, sizeof(addr));
|
|
addr.sin_family = AF_INET;
|
|
addr.sin_port = htons(port);
|
|
if (inet_pton(addr.sin_family, dst, &addr.sin_addr) != 1)
|
|
goto done; /* Could check getaddrinfo */
|
|
|
|
/* special error handling to get understandable messages (otherwise ENOENT) */
|
|
if ((s = socket(addr.sin_family, SOCK_STREAM, 0)) < 0) {
|
|
clicon_err(OE_CFG, errno, "socket");
|
|
return -1;
|
|
}
|
|
if (connect(s, (struct sockaddr*)&addr, sizeof(addr)) < 0){
|
|
clicon_err(OE_CFG, errno, "connecting socket inet4");
|
|
close(s);
|
|
goto done;
|
|
}
|
|
if (clicon_rpc(s, msg, data, datalen, label) < 0)
|
|
goto done;
|
|
if (sock0 != NULL)
|
|
*sock0 = s;
|
|
retval = 0;
|
|
done:
|
|
if (sock0 == NULL && s >= 0)
|
|
close(s);
|
|
return retval;
|
|
}
|
|
|
|
/*! Send a clicon_msg message and wait for result.
|
|
*
|
|
* TBD: timeout, interrupt?
|
|
* retval may be -1 and
|
|
* errno set to ENOTCONN which means that socket is now closed probably
|
|
* due to remote peer disconnecting. The caller may have to do something,...
|
|
*
|
|
* @param[in] s Socket to communicate with backend
|
|
* @param[in] msg CLICON msg data structure. It has fixed header and variable body.
|
|
* @param[out] data Returned data as byte-strin exclusing header.
|
|
* Deallocate w unchunk...(..., label)
|
|
* @param[out] datalen Length of returned data
|
|
* @param[in] label Label used in chunk allocation.
|
|
*/
|
|
int
|
|
clicon_rpc(int s,
|
|
struct clicon_msg *msg,
|
|
char **data,
|
|
uint16_t *datalen,
|
|
const char *label)
|
|
{
|
|
int retval = -1;
|
|
struct clicon_msg *reply;
|
|
int eof;
|
|
uint32_t err;
|
|
uint32_t suberr;
|
|
char *reason;
|
|
enum clicon_msg_type type;
|
|
|
|
if (clicon_msg_send(s, msg) < 0)
|
|
goto done;
|
|
if (clicon_msg_rcv(s, &reply, &eof, label) < 0)
|
|
goto done;
|
|
if (eof){
|
|
clicon_err(OE_PROTO, ESHUTDOWN, "%s: Socket unexpected close", __FUNCTION__);
|
|
close(s);
|
|
errno = ESHUTDOWN;
|
|
goto done;
|
|
}
|
|
type = ntohs(reply->op_type);
|
|
switch (type){
|
|
case CLICON_MSG_OK:
|
|
if (data != NULL) {
|
|
*data = reply->op_body;
|
|
*datalen = ntohs(reply->op_len) - sizeof(*reply);
|
|
}
|
|
break;
|
|
case CLICON_MSG_ERR:
|
|
if (clicon_msg_err_decode(reply, &err, &suberr, &reason, label) < 0)
|
|
goto done;
|
|
clicon_err(err, suberr, "%s", reason);
|
|
goto done;
|
|
break;
|
|
default:
|
|
clicon_err(OE_PROTO, 0, "%s: unexpected reply: %d",
|
|
__FUNCTION__, type);
|
|
goto done;
|
|
break;
|
|
}
|
|
retval = 0;
|
|
done:
|
|
return retval;
|
|
}
|
|
|
|
int
|
|
send_msg_reply(int s,
|
|
uint16_t type,
|
|
char *data,
|
|
uint16_t datalen)
|
|
{
|
|
int retval = -1;
|
|
struct clicon_msg *reply;
|
|
uint16_t len;
|
|
|
|
len = sizeof(*reply) + datalen;
|
|
if ((reply = (struct clicon_msg *)chunk(len, __FUNCTION__)) == NULL)
|
|
goto done;
|
|
memset(reply, 0, len);
|
|
reply->op_type = htons(type);
|
|
reply->op_len = htons(len);
|
|
if (datalen > 0)
|
|
memcpy(reply->op_body, data, datalen);
|
|
if (clicon_msg_send(s, reply) < 0)
|
|
goto done;
|
|
retval = 0;
|
|
done:
|
|
unchunk_group(__FUNCTION__);
|
|
return retval;
|
|
}
|
|
|
|
int
|
|
send_msg_ok(int s)
|
|
{
|
|
return send_msg_reply(s, CLICON_MSG_OK, NULL, 0);
|
|
}
|
|
|
|
int
|
|
send_msg_notify(int s,
|
|
int level,
|
|
char *event)
|
|
{
|
|
int retval = -1;
|
|
struct clicon_msg *msg;
|
|
|
|
if ((msg=clicon_msg_notify_encode(level, event, __FUNCTION__)) == NULL)
|
|
goto done;
|
|
if (clicon_msg_send(s, msg) < 0)
|
|
goto done;
|
|
retval = 0;
|
|
done:
|
|
unchunk_group(__FUNCTION__);
|
|
return retval;
|
|
}
|
|
|
|
int
|
|
send_msg_err(int s, int err, int suberr, char *format, ...)
|
|
{
|
|
va_list args;
|
|
char *reason;
|
|
int len;
|
|
int retval = -1;
|
|
struct clicon_msg *msg;
|
|
|
|
va_start(args, format);
|
|
len = vsnprintf(NULL, 0, format, args) + 1;
|
|
va_end(args);
|
|
if ((reason = (char *)chunk(len, __FUNCTION__)) == NULL)
|
|
return -1;
|
|
memset(reason, 0, len);
|
|
va_start(args, format);
|
|
vsnprintf(reason, len, format, args);
|
|
va_end(args);
|
|
if ((msg=clicon_msg_err_encode(clicon_errno, clicon_suberrno,
|
|
reason, __FUNCTION__)) == NULL)
|
|
goto done;
|
|
if (clicon_msg_send(s, msg) < 0)
|
|
goto done;
|
|
|
|
retval = 0;
|
|
done:
|
|
unchunk_group(__FUNCTION__);
|
|
return retval;
|
|
}
|
|
|