haiwen/ccnet-server
1
0
Fork 0
mirror of https://github.com/haiwen/ccnet-server.git synced 2025-09-24 19:39:50 +00:00
Code Issues Releases Wiki Activity

Initial commit of Ccnet server.

Browse Source
This commit is contained in:
Jiaqiang Xu
2016-08-18 17:39:55 +08:00
commit ed8404c061
206 changed files with 37441 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
include/ccnet/Makefile.am Normal file
View File

@@ -0,0 +1,11 @@
ccnetdir = $(includedir)/ccnet
ccnet_HEADERS = ccnet-client.h peer.h proc-factory.h \
message.h option.h \
processor.h sendcmd-proc.h \
mqclient-proc.h invoke-service-proc.h \
status-code.h cevent.h timer.h ccnet-session-base.h \
valid-check.h job-mgr.h packet.h \
async-rpc-proc.h ccnetrpc-transport.h \
rpcserver-proc.h threaded-rpcserver-proc.h

35
include/ccnet/async-rpc-proc.h Normal file
View File

@@ -0,0 +1,35 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
#ifndef CCNET_ASYNC_RPC_PROC_H
#define CCNET_ASYNC_RPC_PROC_H
#include <glib-object.h>
#define CCNET_TYPE_ASYNC_RPC_PROC (ccnet_async_rpc_proc_get_type ())
#define CCNET_ASYNC_RPC_PROC(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CCNET_TYPE_ASYNC_RPC_PROC, CcnetAsyncRpcProc))
#define CCNET_IS_ASYNC_RPC_PROC(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CCNET_TYPE_ASYNC_RPC_PROC))
#define CCNET_ASYNC_RPC_PROC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CCNET_TYPE_ASYNC_RPC_PROC, CcnetAsyncRpcProcClass))
#define IS_CCNET_ASYNC_RPC_PROC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CCNET_TYPE_ASYNC_RPC_PROC))
#define CCNET_ASYNC_RPC_PROC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CCNET_TYPE_ASYNC_RPC_PROC, CcnetAsyncRpcProcClass))
typedef struct _CcnetAsyncRpcProc CcnetAsyncRpcProc;
typedef struct _CcnetAsyncRpcProcClass CcnetAsyncRpcProcClass;
struct _CcnetAsyncRpcProc {
CcnetProcessor parent_instance;
};
struct _CcnetAsyncRpcProcClass {
CcnetProcessorClass parent_class;
};
GType ccnet_async_rpc_proc_get_type ();
void ccnet_async_rpc_proc_set_rpc (CcnetAsyncRpcProc *proc,
const char *service,
char *fcall_str,
size_t fcall_len,
void *rpc_priv);
#endif

193
include/ccnet/ccnet-client.h Normal file
View File

@@ -0,0 +1,193 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
#ifndef CCNET_CLIENT_SESSION_H
#define CCNET_CLIENT_SESSION_H
#define SESSION_ID_LENGTH 40
#include <glib.h>
#include <glib-object.h>
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
#include <event2/util.h>
#else
#include <evutil.h>
#endif
#include "ccnet-session-base.h"
#define CCNET_TYPE_CLIENT (ccnet_client_get_type ())
#define CCNET_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CCNET_TYPE_CLIENT, CcnetClient))
#define CCNET_IS_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CCNET_TYPE_CLIENT))
#define CCNET_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CCNET_TYPE_CLIENT, CcnetClientClass))
#define CCNET_IS_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CCNET_TYPE_CLIENT))
#define CCNET_CLIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CCNET_TYPE_CLIENT, CcnetClientClass))
typedef struct _CcnetClient CcnetClient;
typedef struct _CcnetClientClass CcnetClientClass;
struct _CcnetPeer;
struct _CcnetUser;
struct _CcnetProcessor;
struct CcnetPacketIO;
#include <ccnet/message.h>
#include <ccnet/processor.h>
#define SESSION_CONFIG_FILENAME "ccnet.conf"
#define CCNET_USER_ID_START 1000
/**
* CcnetClientMode:
* @CCNET_CLIENT_SYNC: Synchronous mode
* @CCNET_CLIENT_ASYNC: Asynchronous mode
*
* #CcnetClient can run in synchronous or asynchronous mode. In
* synchronous mode, every function call to #CcnetClient is blocked
* until the ccnet daemon returns. In asynchronous mode, function
* calls are not blocked, and the user should use the processor
* mechanism to interact with the daemon.
*
**/
typedef enum {
CCNET_CLIENT_SYNC,
CCNET_CLIENT_ASYNC
} CcnetClientMode;
struct CcnetResponse {
char *code;
char *code_msg;
char *content;
int clen; /* content length */
};
typedef struct CcnetClientPriv CcnetClientPriv;
/**
* CcnetClient:
* @id: The ccnet ID in plain text, including the ending '\0'
* @id_sha1: The ccnet ID in binary.
* @id_quark: The ccnet ID in GQuark.
* @name: Ccnet name
* @mode: See #CcnetClientMode
*/
struct _CcnetClient
{
CcnetSessionBase base;
/*< public >*/
int mode;
char *central_config_dir;
char *config_dir;
char *config_file;
int daemon_port;
char *un_path;
int connected : 1;
struct _CcnetProcFactory *proc_factory;
struct _CcnetGroupManager *group_mgr;
/* For processor threads. */
struct _CcnetJobManager *job_mgr;
struct CcnetResponse response;
/*< private >*/
evutil_socket_t connfd;
uint32_t req_id; /* the current request id */
struct CcnetPacketIO *io;
GHashTable *processors;
GList *rpc_pool;
CcnetClientPriv *priv;
};
struct _CcnetClientClass
{
CcnetSessionBaseClass parent_class;
};
GType ccnet_client_get_type (void);
CcnetClient* ccnet_client_new (void);
int ccnet_client_load_confdir (CcnetClient *client, const char *central_config_dir, const char *confdir);
/*
void ccnet_client_add_alias (CcnetClient *client, const char *alias_str);
void ccnet_client_del_alias (CcnetClient *client, const char *alias_str);
gboolean ccnet_client_has_alias (CcnetClient *client, const char *alias_id);
*/
int ccnet_client_connect_daemon (CcnetClient *client, CcnetClientMode mode);
int ccnet_client_disconnect_daemon (CcnetClient *client);
uint32_t ccnet_client_get_request_id (CcnetClient *client);
/* async mode */
void ccnet_client_run_synchronizer (CcnetClient *client);
void ccnet_client_add_processor (CcnetClient *client,
CcnetProcessor *processor);
void ccnet_client_remove_processor (CcnetClient *client,
CcnetProcessor *processor);
CcnetProcessor *
ccnet_client_get_processor (CcnetClient *client, int id);
int ccnet_client_read_input (CcnetClient *client);
/* sync mode */
int ccnet_client_read_response (CcnetClient *client);
void ccnet_client_send_request (CcnetClient *client,
int req_id, const char *req);
void ccnet_client_send_update (CcnetClient *client, int req_id,
const char *code, const char *reason,
const char *content, int clen);
void ccnet_client_send_response (CcnetClient *client, int req_id,
const char *code, const char *reason,
const char *content, int clen);
const char *ccnet_client_send_cmd (CcnetClient *client,
const char *cmd, GError **error);
int ccnet_client_send_message (CcnetClient *client,
CcnetMessage *message);
/* For a sync client to receive a given type of message,
1. call ccnet_client_prepare_recv_message() with the message type you want to receive
2. call ccnet_client_receive_message() repeatly
*/
int
ccnet_client_prepare_recv_message (CcnetClient *client,
const char *app);
CcnetMessage *
ccnet_client_receive_message (CcnetClient *client);
uint32_t
ccnet_client_get_rpc_request_id (CcnetClient *client, const char *peer_id,
const char *service);
void
ccnet_client_clean_rpc_request (CcnetClient *client, uint32_t req_id);
/* void ccnet_client_send_event (CcnetClient *client, GObject *event); */
#endif

47
include/ccnet/ccnet-session-base.h Normal file
View File

@@ -0,0 +1,47 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
#ifndef CCNET_SESSION_BASE_H
#define CCNET_SESSION_BASE_H
#include <glib-object.h>
#define CCNET_TYPE_SESSION_BASE (ccnet_session_base_get_type ())
#define CCNET_SESSION_BASE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CCNET_TYPE_SESSION_BASE, CcnetSessionBase))
#define CCNET_IS_SESSION_BASE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CCNET_TYPE_SESSION_BASE))
#define CCNET_SESSION_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CCNET_TYPE_SESSION_BASE, CcnetSessionBaseClass))
#define CCNET_IS_SESSION_BASE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CCNET_TYPE_SESSION_BASE))
#define CCNET_SESSION_BASE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CCNET_TYPE_SESSION_BASE, CcnetSessionBaseClass))
#define CCNET_PIPE_NAME "ccnet.sock"
typedef struct _CcnetSessionBase CcnetSessionBase;
typedef struct _CcnetSessionBaseClass CcnetSessionBaseClass;
struct _CcnetSessionBase {
GObject parent_instance;
char id[41];
unsigned char id_sha1[20];
char *user_name;
char *name;
int public_port;
int net_status;
char *service_url;
char *relay_id;
};
struct _CcnetSessionBaseClass {
GObjectClass parent_class;
};
GType ccnet_session_base_get_type (void);
CcnetSessionBase *ccnet_session_base_new (void);
#endif

30
include/ccnet/ccnetrpc-transport.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef CCNETRPC_TRANPORT_H
#define CCNETRPC_TRANPORT_H
#include <ccnet.h>
typedef struct {
/* either session or pool will be set. */
CcnetClient *session;
CcnetClientPool *pool;
char *peer_id; /* NULL if local */
char *service;
} CcnetrpcTransportParam; /* this structure will be parsed to
* ccnet_transport_send ()
*/
typedef struct {
CcnetClient *session;
char *peer_id; /* NULL if local */
char *service;
} CcnetrpcAsyncTransportParam; /* this structure will be parsed to
* ccnet_async_transport_send ()
*/
char *ccnetrpc_transport_send (void *arg,
const gchar *fcall_str, size_t fcall_len, size_t *ret_len);
int ccnetrpc_async_transport_send (void *arg, gchar *fcall_str,
size_t fcall_len, void *rpc_priv);
#endif /* SEARPC_TRANPORT_H */

61
include/ccnet/cevent.h Normal file
View File

@@ -0,0 +1,61 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* CEvent is used for send message from a work thread to main thread.
*/
#ifndef CEVENT_H
#define CEVENT_H
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
#include <event2/event.h>
#include <event2/event_compat.h>
#include <event2/event_struct.h>
#else
#include <event.h>
#endif
#include <glib.h>
#include <pthread.h>
#ifdef WIN32
#define ccnet_pipe_t intptr_t
#else
#define ccnet_pipe_t int
#endif
typedef struct CEvent CEvent;
typedef void (*cevent_handler) (CEvent *event, void *handler_data);
struct CEvent {
uint32_t id;
void *data;
};
typedef struct CEventManager CEventManager;
struct CEventManager {
ccnet_pipe_t pipefd[2];
struct event event;
GHashTable *handler_table;
uint32_t next_id;
pthread_mutex_t mutex;
};
CEventManager* cevent_manager_new ();
int cevent_manager_start (CEventManager *manager);
uint32_t cevent_manager_register (CEventManager *manager,
cevent_handler handler, void *handler_data);
void cevent_manager_unregister (CEventManager *manager, uint32_t id);
void cevent_manager_add_event (CEventManager *manager, uint32_t id,
void *event_data);
#endif

39
include/ccnet/invoke-service-proc.h Normal file
View File

@@ -0,0 +1,39 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
#ifndef CCNET_SERVICE_PROC_H
#define CCNET_SERVICE_PROC_H
#include <glib-object.h>
#include "processor.h"
#define CCNET_TYPE_SERVICE_PROC (ccnet_service_proc_get_type ())
#define CCNET_SERVICE_PROC(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CCNET_TYPE_SERVICE_PROC, CcnetServiceProc))
#define CCNET_IS_SERVICE_PROC(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CCNET_TYPE_SERVICE_PROC))
#define CCNET_SERVICE_PROC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CCNET_TYPE_SERVICE_PROC, CcnetServiceProcClass))
#define CCNET_IS_SERVICE_PROC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CCNET_TYPE_SERVICE_PROC))
#define CCNET_SERVICE_PROC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CCNET_TYPE_SERVICE_PROC, CcnetServiceProcClass))
typedef struct _CcnetServiceProc CcnetServiceProc;
typedef struct _CcnetServiceProcClass CcnetServiceProcClass;
typedef void (*ResponseCB) (const char *code, const char *code_msg,
char *content, int clen, void *cb_data);
struct _CcnetServiceProc {
CcnetProcessor parent_instance;
ResponseCB resp_cb;
void *cb_data;
};
struct _CcnetServiceProcClass {
CcnetProcessorClass parent_class;
};
GType ccnet_service_proc_get_type ();
void ccnet_service_proc_set_response_cb (CcnetServiceProc *proc,
ResponseCB resp_cb, void *data);
#endif

57
include/ccnet/job-mgr.h Normal file
View File

@@ -0,0 +1,57 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/**
* Job Manager manages long term jobs. These jobs are run in their
* own threads.
*/
#ifndef JOB_MGR_H
#define JOB_MGR_H
#include <glib.h>
struct _CcnetSession;
typedef struct _CcnetJob CcnetJob;
typedef struct _CcnetJobManager CcnetJobManager;
/*
The thread func should return the result back by
return (void *)result;
The result will be passed to JobDoneCallback.
*/
typedef void* (*JobThreadFunc)(void *data);
typedef void (*JobDoneCallback)(void *result);
struct _CcnetJobManager {
GHashTable *jobs;
GThreadPool *thread_pool;
int next_job_id;
};
void
ccnet_job_cancel (CcnetJob *job);
CcnetJobManager *
ccnet_job_manager_new (int max_threads);
void
ccnet_job_manager_free (CcnetJobManager *mgr);
int
ccnet_job_manager_schedule_job (CcnetJobManager *mgr,
JobThreadFunc func,
JobDoneCallback done_func,
void *data);
/**
* Wait a specific job to be done.
*/
void
ccnet_job_manager_wait_job (CcnetJobManager *mgr, int job_id);
#endif

78
include/ccnet/message.h Normal file
View File

@@ -0,0 +1,78 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
#ifndef CCNET_MESSAGE_H
#define CCNET_MESSAGE_H
#include <glib.h>
#include <glib-object.h>
#define CCNET_TYPE_MESSAGE (ccnet_message_get_type ())
#define CCNET_MESSAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CCNET_TYPE_MESSAGE, CcnetMessage))
#define CCNET_IS_MESSAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CCNET_TYPE_MESSAGE))
#define CCNET_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CCNET_TYPE_MESSAGE, CcnetMessageClass))
#define CCNET_IS_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CCNET_TYPE_MESSAGE))
#define CCNET_MESSAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CCNET_TYPE_MESSAGE, CcnetMessageClass))
typedef struct _CcnetMessage CcnetMessage;
typedef struct _CcnetMessageClass CcnetMessageClass;
#define FLAG_TO_GROUP 0x01
#define FLAG_IS_ERROR 0x02
#define FLAG_WITH_BLOOM 0x04
#define FLAG_IS_ACK 0x08
#define FLAG_IS_RENDEZVOUS 0x10
#define FLAG_TO_USER 0x20
struct _CcnetMessage
{
GObject parent_instance;
char flags;
char *id; /* UUID */
char from[41];
char to[41];
int ctime; /* creation time */
int rtime; /* receive time */
char *app; /* application */
char *body;
};
struct _CcnetMessageClass
{
GObjectClass parent_class;
};
GType ccnet_message_get_type (void);
CcnetMessage* ccnet_message_new (const char *from_id,
const char *to_id,
const char *app,
const char *body,
int flags);
CcnetMessage* ccnet_message_new_full (const char *from_id,
const char *to_id,
const char *app,
const char *body,
time_t ctime,
time_t rcv_time,
const char *msg_id,
int flags);
void ccnet_message_free (CcnetMessage *msg);
void ccnet_message_to_string_buf (CcnetMessage *msg, GString *buf);
CcnetMessage *ccnet_message_from_string (char *buf, int len);
gboolean ccnet_message_is_to_group(CcnetMessage *msg);
/* to avoid string allocation */
/* inline void ccnet_message_body_take (CcnetMessage *msg, char *body); */
/* inline void ccnet_message_body_dup (CcnetMessage *msg, char *body); */
#endif

44
include/ccnet/mqclient-proc.h Normal file
View File

@@ -0,0 +1,44 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
#ifndef CCNET_MQCLIENT_PROC_H
#define CCNET_MQCLIENT_PROC_H
#include <glib-object.h>
#include "processor.h"
#include "message.h"
#define CCNET_TYPE_MQCLIENT_PROC (ccnet_mqclient_proc_get_type ())
#define CCNET_MQCLIENT_PROC(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CCNET_TYPE_MQCLIENT_PROC, CcnetMqclientProc))
#define CCNET_IS_MQCLIENT_PROC(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CCNET_TYPE_MQCLIENT_PROC))
#define CCNET_MQCLIENT_PROC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CCNET_TYPE_MQCLIENT_PROC, CcnetMqclientProcClass))
#define CCNET_IS_MQCLIENT_PROC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CCNET_TYPE_MQCLIENT_PROC))
#define CCNET_MQCLIENT_PROC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CCNET_TYPE_MQCLIENT_PROC, CcnetMqclientProcClass))
typedef struct _CcnetMqclientProc CcnetMqclientProc;
typedef struct _CcnetMqclientProcClass CcnetMqclientProcClass;
typedef void (*MessageGotCB) (CcnetMessage *message, void *data);
struct _CcnetMqclientProc {
CcnetProcessor parent_instance;
MessageGotCB message_got_cb;
void *cb_data;
};
struct _CcnetMqclientProcClass {
CcnetProcessorClass parent_class;
};
void ccnet_mqclient_proc_set_message_got_cb (CcnetMqclientProc *,
MessageGotCB, void *);
GType ccnet_mqclient_proc_get_type ();
void ccnet_mqclient_proc_put_message (CcnetMqclientProc *proc,
CcnetMessage *message);
void ccnet_mqclient_proc_unsubscribe_apps (CcnetMqclientProc *proc);
#endif

50
include/ccnet/option.h Normal file
View File

@@ -0,0 +1,50 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
#ifndef CCNET_OPTION_H
#define CCNET_OPTION_H
#include <stdio.h>
#include <glib.h>
#ifdef WIN32
static inline char *GetDeafaultDir()
{
static char buf[128];
static int inited = 0;
if (!inited) {
const char *home = g_get_home_dir();
inited = 1;
snprintf(buf, 128, "%s/ccnet", home);
}
return buf;
}
#define DEFAULT_CONFIG_DIR GetDeafaultDir()
#define CONFIG_FILE_NAME "ccnet.conf"
#define PREFS_FILE_NAME "prefs.conf"
#else
#define DEFAULT_CONFIG_DIR "~/.ccnet"
#define CONFIG_FILE_NAME "ccnet.conf"
#define PREFS_FILE_NAME "prefs.conf"
#endif
#define PEER_KEYFILE "mykey.peer"
#define MAX_USERNAME_LEN 20
#define MIN_USERNAME_LEN 2
#define DEFAULT_PORT 10001
#define CHAT_APP "Chat"
#define PEERMGR_APP "PeerMgr"
#define GROUPMGR_APP "GroupMgr"
enum {
NET_STATUS_DOWN,
NET_STATUS_INNAT,
NET_STATUS_FULL
};
#endif

34
include/ccnet/packet.h Normal file
View File

@@ -0,0 +1,34 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
#ifndef CCNET_PEER_MSG
#define CCNET_PEER_MSG
#define CCNET_MSG_OK 0
#define CCNET_MSG_HANDSHAKE 1
#define CCNET_MSG_REQUEST 2
#define CCNET_MSG_RESPONSE 3
#define CCNET_MSG_UPDATE 4
#define CCNET_MSG_RELAY 5 /* NOT USED NOW */
#define CCNET_MSG_ENCPACKET 6 /* an encrypt packet */
typedef struct ccnet_header ccnet_header;
struct ccnet_header {
uint8_t version;
uint8_t type;
uint16_t length; /* length of payload */
uint32_t id; /* used as length in ecrypted packet */
};
typedef struct ccnet_packet ccnet_packet;
struct ccnet_packet {
struct ccnet_header header;
char data[0];
};
#define CCNET_PACKET_MAX_PAYLOAD_LEN 65535
#define CCNET_PACKET_LENGTH_HEADER 8
#define CCNET_USER_ID_START 1000
#endif

88
include/ccnet/peer.h Normal file
View File

@@ -0,0 +1,88 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
#ifndef CCNET_PEER_H
#define CCNET_PEER_H
#include <glib.h>
#include <glib-object.h>
#include <stdint.h>
#define CCNET_TYPE_PEER (ccnet_peer_get_type ())
#define CCNET_PEER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CCNET_TYPE_PEER, CcnetPeer))
#define CCNET_IS_PEER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CCNET_TYPE_PEER))
#define CCNET_PEER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CCNET_TYPE_PEER, CcnetPeerClass))
#define CCNET_IS_PEER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CCNET_TYPE_PEER))
#define CCNET_PEER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CCNET_TYPE_PEER, CcnetPeerClass))
enum {
PEER_DOWN,
PEER_CONNECTED
};
enum {
BIND_UNKNOWN,
BIND_YES,
BIND_NO
};
typedef struct _CcnetPeer CcnetPeer;
typedef struct _CcnetPeerClass CcnetPeerClass;
#define CCNET_PEERID_LEN 40
struct _CcnetPeer
{
GObject parent_instance;
char id[41];
char user_id[41];
gint64 timestamp;
char *name;
unsigned int is_self : 1;
unsigned int can_connect : 1;
unsigned int in_local_network : 1;
unsigned int in_connection : 1;
unsigned int is_ready : 1;
unsigned int encrypt_channel : 1;
gboolean login_started;
char *login_error;
gboolean logout_started;
char *public_addr;
uint16_t public_port;
char *service_url; /* http server for relay in seaflie */
char *addr_str;
uint16_t port;
int net_state;
GList *role_list;
GList *myrole_list; /* my role on this user */
gint8 bind_status;
char *bind_email;
char *session_key;
};
struct _CcnetPeerClass
{
GObjectClass parent_class;
};
GType ccnet_peer_get_type (void);
CcnetPeer* ccnet_peer_new (const char *id);
#endif

74
include/ccnet/proc-factory.h Normal file
View File

@@ -0,0 +1,74 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
#ifndef CCNET_PROC_FACTORY_H
#define CCNET_PROC_FACTORY_H
#include <glib-object.h>
#include "processor.h"
#define CCNET_TYPE_PROC_FACTORY (ccnet_proc_factory_get_type ())
#define CCNET_PROC_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CCNET_TYPE_PROC_FACTORY, CcnetProcFactory))
#define CCNET_IS_PROC_FACTORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CCNET_TYPE_PROC_FACTORY))
#define CCNET_PROC_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CCNET_TYPE_PROC_FACTORY, CcnetProcFactoryClass))
#define CCNET_IS_PROC_FACTORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CCNET_TYPE_PROC_FACTORY))
#define CCNET_PROC_FACTORY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CCNET_TYPE_PROC_FACTORY, CcnetProcFactoryClass))
typedef struct _CcnetProcFactory CcnetProcFactory;
typedef struct _CcnetProcFactoryClass CcnetProcFactoryClass;
struct _CcnetProcFactory
{
GObject parent_instance;
/* protected */
CcnetClient *session;
};
struct _CcnetProcFactoryClass
{
GObjectClass parent_class;
};
GType ccnet_proc_factory_get_type (void);
CcnetProcFactory *ccnet_proc_factory_new (CcnetClient *session);
void ccnet_proc_factory_register_processor (CcnetProcFactory *facotry,
const char *serv_name,
GType proc_type);
enum {
SLAVE = 0,
MASTER = 1,
};
CcnetProcessor*
ccnet_proc_factory_create_processor (CcnetProcFactory *factory,
const char *serv_name,
int is_master,
int req_id);
CcnetProcessor*
ccnet_proc_factory_create_master_processor (CcnetProcFactory *factory,
const char *serv_name);
CcnetProcessor *
ccnet_proc_factory_create_remote_master_processor (CcnetProcFactory *factory,
const char *serv_name,
const char *peer_id);
CcnetProcessor *
ccnet_proc_factory_create_slave_processor (CcnetProcFactory *factory,
const char *serv_name,
const char *peer_id,
int req_id);
void ccnet_proc_factory_recycle(CcnetProcFactory *factory,
CcnetProcessor *processor);
#endif

168
include/ccnet/processor.h Normal file
View File

@@ -0,0 +1,168 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
#ifndef CCNET_PROCESSOR_H
#define CCNET_PROCESSOR_H
#include <glib.h>
#include <glib-object.h>
#include <stdint.h>
#include <ccnet/status-code.h>
#include <pthread.h>
#ifdef WIN32
#define ccnet_pipe_t intptr_t
#else
#define ccnet_pipe_t int
#endif
struct _CcnetClient;
#define CCNET_TYPE_PROCESSOR (ccnet_processor_get_type ())
#define CCNET_PROCESSOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CCNET_TYPE_PROCESSOR, CcnetProcessor))
#define CCNET_IS_PROCESSOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CCNET_TYPE_PROCESSOR))
#define CCNET_PROCESSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CCNET_TYPE_PROCESSOR, CcnetProcessorClass))
#define CCNET_IS_PROCESSOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CCNET_TYPE_PROCESSOR))
#define CCNET_PROCESSOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CCNET_TYPE_PROCESSOR, CcnetProcessorClass))
typedef struct _CcnetProcessor CcnetProcessor;
typedef struct _CcnetProcessorClass CcnetProcessorClass;
struct _CcnetProcessor {
GObject parent_instance;
char *peer_id;
struct _CcnetClient *session;
char *name;
/* highest bit = 0, master; highest bit = 1, slave */
uint32_t id;
int state;
int failure;
struct CcnetTimer *timer;
int num_retry;
/* Set to 1 when handling update or response */
gboolean is_active;
/* Internal flags for handling processor thread. */
gboolean thread_running;
gboolean delay_shutdown;
gboolean was_success;
};
enum {
STATE_IN_SHUTDOWN = 1 << 8,
STATE_RECYCLED,
};
enum {
PROC_NOTSET,
PROC_DONE,
PROC_REMOTE_DEAD,
PROC_NO_SERVICE,
PROC_PERM_ERR,
PROC_BAD_RESP, /* code[0] =='5' || '4' */
};
#define SLAVE_MASK 0x80000000
#define REQUEST_ID_MASK 0x7fffffff
#define REQUEST_ID(processor_id) ((processor_id) & REQUEST_ID_MASK)
#define UPDATE_ID(processor_id) ((processor_id) & REQUEST_ID_MASK)
#define RESPONSE_ID(processor_id) ((processor_id) & REQUEST_ID_MASK)
#define SLAVE_ID(request_id) ((request_id) | SLAVE_MASK)
#define MASTER_ID(request_id) (request_id)
#define PRINT_ID(processor_id) ((processor_id) & SLAVE_MASK) ? \
- REQUEST_ID(processor_id) : REQUEST_ID(processor_id)
#define IS_SLAVE(processor) ((processor)->id & SLAVE_MASK)
#define GET_PNAME(processor) CCNET_PROCESSOR_GET_CLASS(processor)->name
struct _CcnetProcessorClass {
GObjectClass parent_class;
char *name;
/* pure virtual function */
int (*start) (CcnetProcessor *processor,
int argc, char **argv);
void (*handle_update) (CcnetProcessor *processor,
char *code, char *code_msg,
char *content, int clen);
void (*handle_response) (CcnetProcessor *processor,
char *code, char *code_msg,
char *content, int clen);
void (*handle_sigchld) (CcnetProcessor *processor,
int status);
void (*shutdown) (CcnetProcessor *processor);
void (*release_resource) (CcnetProcessor *processor);
};
GType ccnet_processor_get_type ();
int ccnet_processor_start (CcnetProcessor *processor,
int argc, char **argv);
int ccnet_processor_startl
(CcnetProcessor *processor, ...) G_GNUC_NULL_TERMINATED;
void ccnet_processor_done (CcnetProcessor *processor, gboolean success);
void ccnet_processor_handle_update (CcnetProcessor *processor,
char *code, char *code_msg,
char *content, int clen);
void ccnet_processor_handle_response (CcnetProcessor *processor,
char *code, char *code_msg,
char *content, int clen);
void ccnet_processor_handle_sigchld (CcnetProcessor *processor,
int status);
void ccnet_processor_send_request (CcnetProcessor *processor,
const char *request);
void ccnet_processor_send_request_l (CcnetProcessor *processor,
...) G_GNUC_NULL_TERMINATED;
void ccnet_processor_send_update(CcnetProcessor *processor,
const char *code,
const char *code_msg,
const char *content, int clen);
void ccnet_processor_send_response(CcnetProcessor *processor,
const char *code,
const char *code_msg,
const char *content, int clen);
/*
The thread func should return the result back by
return (void *)result;
The result will be passed to ProcThreadDoneFunc.
In the done func, the caller should check whether processor->delay_shutdown
is TRUE. If it is, you should call processor_done().
*/
typedef void* (*ProcThreadFunc)(void *data);
typedef void (*ProcThreadDoneFunc)(void *result);
struct _CcnetJobManager;
/*
* @job_mgr: the thread pool to create the worker thread.
* If it's NULL, processor->session->job_mgr will be used.
*/
int ccnet_processor_thread_create (CcnetProcessor *processor,
struct _CcnetJobManager *job_mgr,
ProcThreadFunc func,
ProcThreadDoneFunc done_func,
void *data);
#endif

30
include/ccnet/rpcserver-proc.h Normal file
View File

@@ -0,0 +1,30 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
#ifndef CCNET_RPCSERVER_PROC_H
#define CCNET_RPCSERVER_PROC_H
#include <glib-object.h>
#define CCNET_TYPE_RPCSERVER_PROC (ccnet_rpcserver_proc_get_type ())
#define CCNET_RPCSERVER_PROC(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CCNET_TYPE_RPCSERVER_PROC, CcnetRpcserverProc))
#define CCNET_IS_RPCSERVER_PROC(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CCNET_TYPE_RPCSERVER_PROC))
#define CCNET_RPCSERVER_PROC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CCNET_TYPE_RPCSERVER_PROC, CcnetRpcserverProcClass))
#define IS_CCNET_RPCSERVER_PROC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CCNET_TYPE_RPCSERVER_PROC))
#define CCNET_RPCSERVER_PROC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CCNET_TYPE_RPCSERVER_PROC, CcnetRpcserverProcClass))
typedef struct _CcnetRpcserverProc CcnetRpcserverProc;
typedef struct _CcnetRpcserverProcClass CcnetRpcserverProcClass;
struct _CcnetRpcserverProc {
CcnetProcessor parent_instance;
};
struct _CcnetRpcserverProcClass {
CcnetProcessorClass parent_class;
};
GType ccnet_rpcserver_proc_get_type ();
#endif

41
include/ccnet/sendcmd-proc.h Normal file
View File

@@ -0,0 +1,41 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
#ifndef CCNET_CMD_PROC_H
#define CCNET_CMD_PROC_H
#include <glib-object.h>
#include "processor.h"
#define CCNET_TYPE_SENDCMD_PROC (ccnet_sendcmd_proc_get_type ())
#define CCNET_SENDCMD_PROC(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CCNET_TYPE_SENDCMD_PROC, CcnetSendcmdProc))
#define CCNET_IS_SENDCMD_PROC(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CCNET_TYPE_SENDCMD_PROC))
#define CCNET_SENDCMD_PROC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CCNET_TYPE_SENDCMD_PROC, CcnetSendcmdProcClass))
#define CCNET_IS_SENDCMD_PROC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CCNET_TYPE_SENDCMD_PROC))
#define CCNET_SENDCMD_PROC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CCNET_TYPE_SENDCMD_PROC, CcnetSendcmdProcClass))
typedef struct _CcnetSendcmdProc CcnetSendcmdProc;
typedef struct _CcnetSendcmdProcClass CcnetSendcmdProcClass;
typedef int (*SendcmdProcRcvrspCallback) (const char *code, char *content,
int clen, void *data);
struct _CcnetSendcmdProc {
CcnetProcessor parent_instance;
SendcmdProcRcvrspCallback rcvrsp_cb;
void *cb_data;
};
struct _CcnetSendcmdProcClass {
CcnetProcessorClass parent_class;
};
GType ccnet_sendcmd_proc_get_type ();
int ccnet_sendcmd_proc_send_command (CcnetSendcmdProc *proc, const char *cmd);
void ccnet_sendcmd_proc_set_rcvrsp_cb (CcnetSendcmdProc *proc,
SendcmdProcRcvrspCallback rcvrsp_cb,
void *data);
#endif

64
include/ccnet/status-code.h Normal file
View File

@@ -0,0 +1,64 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
#ifndef STATUS_CODE_H
#define STATUS_CODE_H
/* SC: Status Code. SS: Status String */
/* Error Code for use in GError */
#define EC_NETWORK_ERR 1
#define ES_NETWORK_ERR "Network Error"
#define SC_PROC_KEEPALIVE "100"
#define SS_PROC_KEEPALIVE "processor keep alive"
#define SC_PROC_ALIVE "101"
#define SS_PROC_ALIVE "processor is alive"
#define SC_PROC_DEAD "102"
#define SS_PROC_DEAD "processor is dead"
#define SC_PROC_DONE "103"
#define SS_PROC_DONE "service is done"
#define SC_OK "200"
#define SS_OK "OK"
#define SC_PERM_CHECKING "250"
#define SS_PERM_CHECKING "Permission Checking"
#define SC_SHUTDOWN "500"
#define SS_SHUTDOWN "Shutdown"
#define SC_CREATE_PROC_ERR "501"
#define SS_CREATE_PROC_ERR "Create Processor Error"
#define SC_BAD_PEER "502"
#define SS_BAD_PEER "Bad peer id"
#define SC_BAD_USER "502"
#define SS_BAD_USER "Bad user id"
#define SC_BAD_ARGS "503"
#define SS_BAD_ARGS "Bad arguments"
#define SC_PERM_ERR "504"
#define SS_PERM_ERR "Permission Error"
#define SC_BAD_UPDATE_CODE "506"
#define SS_BAD_UPDATE_CODE "Bad update code"
#define SC_BAD_RESPONSE_CODE "507"
#define SS_BAD_RESPONSE_CODE "Bad response code"
#define SC_VERSION_MISMATCH "508"
#define SS_VERSION_MISMATCH "Version Mismatch"
#define SC_UNKNOWN_PEER "510"
#define SS_UNKNOWN_PEER "Unknown peer"
#define SC_UNKNOWN_SERVICE "511"
#define SS_UNKNOWN_SERVICE "Unknown service"
#define SC_UNKNOWN_SERVICE_IN_PERM "511"
#define SS_UNKNOWN_SERVICE_IN_PERM "Unknown service in permission check"
#define SC_PEER_UNREACHABLE "512"
#define SS_PEER_UNREACHABLE "Peer Unreachable"
#define SC_CON_TIMEOUT "513"
#define SS_CON_TIMEOUT "connection timeout"
#define SC_KEEPALIVE_TIMEOUT "514"
#define SS_KEEPALIVE_TIMEOUT "keepalive timeout"
#define SC_NETDOWN "515"
#define SS_NETDOWN "peer down"
#define SC_SERV_EXISTED "516"
#define SS_SERV_EXISTED "The service existed"
#endif

30
include/ccnet/threaded-rpcserver-proc.h Normal file
View File

@@ -0,0 +1,30 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
#ifndef CCNET_THREADED_RPCSERVER_PROC_H
#define CCNET_THREADED_RPCSERVER_PROC_H
#include <glib-object.h>
#define CCNET_TYPE_THREADED_RPCSERVER_PROC (ccnet_threaded_rpcserver_proc_get_type ())
#define CCNET_THREADED_RPCSERVER_PROC(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CCNET_TYPE_THREADED_RPCSERVER_PROC, CcnetThreadedRpcserverProc))
#define CCNET_IS_THREADED_RPCSERVER_PROC(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CCNET_TYPE_THREADED_RPCSERVER_PROC))
#define CCNET_THREADED_RPCSERVER_PROC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CCNET_TYPE_THREADED_RPCSERVER_PROC, CcnetThreadedRpcserverProcClass))
#define IS_CCNET_THREADED_RPCSERVER_PROC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CCNET_TYPE_THREADED_RPCSERVER_PROC))
#define CCNET_THREADED_RPCSERVER_PROC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CCNET_TYPE_THREADED_RPCSERVER_PROC, CcnetThreadedRpcserverProcClass))
typedef struct _CcnetThreadedRpcserverProc CcnetThreadedRpcserverProc;
typedef struct _CcnetThreadedRpcserverProcClass CcnetThreadedRpcserverProcClass;
struct _CcnetThreadedRpcserverProc {
CcnetProcessor parent_instance;
};
struct _CcnetThreadedRpcserverProcClass {
CcnetProcessorClass parent_class;
};
GType ccnet_threaded_rpcserver_proc_get_type ();
#endif

28
include/ccnet/timer.h Normal file
View File

@@ -0,0 +1,28 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
#ifndef CCNET_TIMER_H
#define CCNET_TIMER_H
/* return TRUE to reschedule the timer, return FALSE to cancle the timer */
typedef int (*TimerCB) (void *data);
struct CcnetTimer;
typedef struct CcnetTimer CcnetTimer;
/**
* Calls timer_func(user_data) after the specified interval.
* The timer is freed if timer_func returns zero.
* Otherwise, it's called again after the same interval.
*/
CcnetTimer* ccnet_timer_new (TimerCB func,
void *user_data,
uint64_t timeout_milliseconds);
/**
* Frees a timer and sets the timer pointer to NULL.
*/
void ccnet_timer_free (CcnetTimer **timer);
#endif

29
include/ccnet/valid-check.h Normal file
View File

@@ -0,0 +1,29 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
#ifndef VALID_CHECK_H
#define VALID_CHECK_H
#include <string.h>
inline static gboolean user_id_valid(const char *id)
{
if (!id || strlen(id) != 40)
return FALSE;
return TRUE;
}
inline static gboolean peer_id_valid(const char *id)
{
if (!id || strlen(id) != 40)
return FALSE;
return TRUE;
}
gboolean is_uuid_valid (const char *uuid_str);
inline static gboolean group_id_valid(const char *id)
{
return is_uuid_valid(id);
}
#endif