mirror of
https://github.com/unrealircd/unrealircd.git
synced 2026-06-28 05:16:38 +02:00
Bram Matthys
6a4ae9d9ec
sent over the IRC network. This makes it possible to fetch information from remote servers that is not known locally, and also it makes it possible to do more things, or do it easier. This does require the remote servers to enable RPC as well, though, eg: include "rpc.modules.default.conf"; (They don't need any listener or rpc-user blocks) Code-wise it looks nice, like from rpc_server_module_list it is a simple: /* Forward to remote */ rpc_send_request_to_remote(client, targetserver, request); This is work in progress. In particular, there is no handling yet of timeouts (eg if the request to the remote server, or the response from it takes ages). Nor does it handle the case where the server quits half-way through the request/response... that is: it does free the request and such, but does not notify the RPC client about it. That will need to be added, of course, likely soon. Over the IRC network this uses the new RRPC command: :<server> RRPC <REQ|RES> <source> <destination> <requestid> [S|C|F] :<request data> A request looks like this (assuming it is short): :001 RRPC REQ 001ABCDEF 002 abc SF :..this is the json request... And then the response (assuming it is long) is like: :001 RRPC REQ 001ABCDEF 002 abc S :..this is the json response... :001 RRPC REQ 001ABCDEF 002 abc C :..more... :001 RRPC REQ 001ABCDEF 002 abc C :..more... :001 RRPC REQ 001ABCDEF 002 abc F :..and that was it. There is currently no request/response limit, it is limited by memory. Right now the only call using this is server.module_list when called with a param of "server":"some.remote.server"
103 lines
3.2 KiB
C
103 lines
3.2 KiB
C
/************************************************************************
|
|
* Unreal Internet Relay Chat Daemon, include/dbuf.h
|
|
* Copyright (C) 1990 Markku Savela
|
|
* Copyright (C) 2013 William Pitcock <nenolod@dereferenced.org>
|
|
*
|
|
* This program 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 1, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This program 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 this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*
|
|
* $Id$
|
|
*/
|
|
|
|
#ifndef __dbuf_include__
|
|
#define __dbuf_include__
|
|
|
|
#include "list.h"
|
|
|
|
/* 512 bytes -- 510 character bytes + \r\n, per rfc1459 */
|
|
#define DBUF_BLOCK_SIZE (512)
|
|
|
|
/*
|
|
** dbuf is a collection of functions which can be used to
|
|
** maintain a dynamic buffering of a byte stream.
|
|
** Functions allocate and release memory dynamically as
|
|
** required [Actually, there is nothing that prevents
|
|
** this package maintaining the buffer on disk, either]
|
|
*/
|
|
|
|
/*
|
|
** These structure definitions are only here to be used
|
|
** as a whole, *DO NOT EVER REFER TO THESE FIELDS INSIDE
|
|
** THE STRUCTURES*! It must be possible to change the internal
|
|
** implementation of this package without changing the
|
|
** interface.
|
|
*/
|
|
typedef struct dbuf {
|
|
u_int length; /* Current number of bytes stored */
|
|
// u_int offset; /* Offset to the first byte */
|
|
struct list_head dbuf_list;
|
|
} dbuf;
|
|
|
|
/*
|
|
** And this 'dbufbuf' should never be referenced outside the
|
|
** implementation of 'dbuf'--would be "hidden" if C had such
|
|
** keyword...
|
|
** If it was possible, this would compile to be exactly 1 memory
|
|
** page in size. 2048 bytes seems to be the most common size, so
|
|
** as long as a pointer is 4 bytes, we get 2032 bytes for buffer
|
|
** data after we take away a bit for malloc to play with. -avalon
|
|
*/
|
|
typedef struct dbufbuf {
|
|
struct list_head dbuf_node;
|
|
size_t size;
|
|
char data[DBUF_BLOCK_SIZE];
|
|
} dbufbuf;
|
|
|
|
/*
|
|
** dbuf_put
|
|
** Append the number of bytes to the buffer, allocating more
|
|
** memory as needed. Bytes are copied into internal buffers
|
|
** from users buffer.
|
|
*/
|
|
void dbuf_put(dbuf *, const char *, size_t);
|
|
/* Dynamic buffer header */
|
|
/* Pointer to data to be stored */
|
|
/* Number of bytes to store */
|
|
|
|
void dbuf_delete(dbuf *, size_t);
|
|
/* Dynamic buffer header */
|
|
/* Number of bytes to delete */
|
|
|
|
/*
|
|
** DBufLength
|
|
** Return the current number of bytes stored into the buffer.
|
|
** (One should use this instead of referencing the internal
|
|
** length field explicitly...)
|
|
*/
|
|
#define DBufLength(dyn) ((dyn)->length)
|
|
|
|
/*
|
|
** DBufClear
|
|
** Scratch the current content of the buffer. Release all
|
|
** allocated buffers and make it empty.
|
|
*/
|
|
#define DBufClear(dyn) dbuf_delete((dyn),DBufLength(dyn))
|
|
|
|
extern int dbuf_getmsg(dbuf *, char *);
|
|
extern int dbuf_get(dbuf *dyn, char **buf);
|
|
extern void dbuf_queue_init(dbuf *dyn);
|
|
extern void dbuf_init(void);
|
|
|
|
#endif /* __dbuf_include__ */
|