/**
* couchdb_document_contact_im_new:
* @uuid: A unique ID
* @address: IM address
* @description: Description for this IM address
* @protocol: Protocol used for this IM address
*
* Returns a #CouchdbStructField representing the given IM address.
*
* Returns: (transfer full): A newly-created #CouchdbStructField representing
* the given IM address information.
*/
CouchdbStructField *
couchdb_document_contact_im_new (const char *uuid,
const char *address,
const char *description,
const char *protocol)
{
CouchdbStructField *sf;
sf = couchdb_struct_field_new_from_json_object (json_object_new ());
if (uuid != NULL)
couchdb_struct_field_set_uuid (sf, uuid);
else {
char *new_uuid = generate_uuid ();
couchdb_struct_field_set_uuid (sf, new_uuid);
g_free (new_uuid);
}
if (address != NULL)
couchdb_document_contact_im_set_address (sf, address);
if (description != NULL)
couchdb_document_contact_im_set_description (sf, description);
if (protocol != NULL)
couchdb_document_contact_im_set_protocol (sf, protocol);
return sf;
}
zmq::zmq_init_t::zmq_init_t (io_thread_t *io_thread_,
socket_base_t *socket_, session_t *session_, fd_t fd_,
const options_t &options_) :
own_t (io_thread_, options_),
ephemeral_engine (NULL),
received (false),
socket (socket_),
session (session_),
io_thread (io_thread_)
{
// Create the engine object for this connection.
engine = new (std::nothrow) zmq_engine_t (fd_, options);
alloc_assert (engine);
// Generate an unique identity.
peer_identity.resize (17);
peer_identity [0] = 0;
generate_uuid (&peer_identity [1]);
// Create a list of messages to send on connection initialisation.
if (!options.identity.empty ()) {
msg_t msg;
int rc = msg.init_size (options.identity.size ());
errno_assert (rc == 0);
memcpy (msg.data () , options.identity.data (), msg.size ());
to_send.push_back (msg);
}
else {
msg_t msg;
int rc = msg.init ();
errno_assert (rc == 0);
to_send.push_back (msg);
}
}
static int
glusterfs_ctx_defaults_init (glusterfs_ctx_t *ctx)
{
cmd_args_t *cmd_args = NULL;
struct rlimit lim = {0, };
call_pool_t *pool = NULL;
xlator_mem_acct_init (THIS, cli_mt_end);
ctx->process_uuid = generate_uuid ();
if (!ctx->process_uuid)
return -1;
ctx->page_size = 128 * GF_UNIT_KB;
ctx->iobuf_pool = iobuf_pool_new (8 * GF_UNIT_MB, ctx->page_size);
if (!ctx->iobuf_pool)
return -1;
ctx->event_pool = event_pool_new (DEFAULT_EVENT_POOL_SIZE);
if (!ctx->event_pool)
return -1;
pool = GF_CALLOC (1, sizeof (call_pool_t),
cli_mt_call_pool_t);
if (!pool)
return -1;
/* frame_mem_pool size 112 * 16k */
pool->frame_mem_pool = mem_pool_new (call_frame_t, 16384);
if (!pool->frame_mem_pool)
return -1;
/* stack_mem_pool size 256 * 8k */
pool->stack_mem_pool = mem_pool_new (call_stack_t, 8192);
if (!pool->stack_mem_pool)
return -1;
ctx->stub_mem_pool = mem_pool_new (call_stub_t, 1024);
if (!ctx->stub_mem_pool)
return -1;
INIT_LIST_HEAD (&pool->all_frames);
LOCK_INIT (&pool->lock);
ctx->pool = pool;
pthread_mutex_init (&(ctx->lock), NULL);
cmd_args = &ctx->cmd_args;
INIT_LIST_HEAD (&cmd_args->xlator_options);
lim.rlim_cur = RLIM_INFINITY;
lim.rlim_max = RLIM_INFINITY;
setrlimit (RLIMIT_CORE, &lim);
return 0;
}
/**
* Assign a new message id for a client. Make sure it isn't already being used and does
* not exceed the maximum.
* @param client a client structure
* @return the next message id to use, or 0 if none available
*/
uint64_t MQTTProtocol_assignMsgId(Clients* client)
{
uint64_t msgid;
FUNC_ENTRY;
msgid = generate_uuid();
client->msgID = msgid;
FUNC_EXIT_RC(msgid);
return msgid;
#if 0
int start_msgid = client->msgID;
uint64_t msgid = start_msgid;
FUNC_ENTRY;
msgid = (msgid == MAX_MSG_ID) ? 1 : msgid + 1;
while (ListFindItem(client->outboundMsgs, &msgid, messageIDCompare) != NULL)
{
msgid = (msgid == MAX_MSG_ID) ? 1 : msgid + 1;
if (msgid == start_msgid)
{ /* we've tried them all - none free */
msgid = 0;
break;
}
}
if (msgid != 0)
client->msgID = msgid;
FUNC_EXIT_RC(msgid);
return msgid;
#endif
}
void zmq::socket_base_t::attach_pipe (pipe_t *pipe_,
const blob_t &peer_identity_)
{
// First, register the pipe so that we can terminate it later on.
pipe_->set_event_sink (this);
pipes.push_back (pipe_);
// Then, pass the pipe to the specific socket type.
// If the peer haven't specified it's identity, let's generate one.
if (peer_identity_.size ()) {
xattach_pipe (pipe_, peer_identity_);
}
else {
blob_t identity (17, 0);
generate_uuid ((unsigned char*) identity.data () + 1);
xattach_pipe (pipe_, identity);
}
// If the socket is already being closed, ask any new pipes to terminate
// straight away.
if (is_terminating ()) {
register_term_acks (1);
pipe_->terminate (false);
}
}
int
outbound_addressing_filter(SoapOpH opHandle, void *data, void *opaqueData)
{
WsXmlDocH in_doc = soap_get_op_doc(opHandle, 1);
WsXmlDocH out_doc = soap_get_op_doc(opHandle, 0);
WsXmlNodeH outHeaders = wsman_get_soap_header_element(out_doc, NULL, NULL);
if (!outHeaders) {
return 0;
}
if (ws_xml_get_child(outHeaders, 0, XML_NS_ADDRESSING, WSA_MESSAGE_ID) == NULL &&
!wsman_is_identify_request(in_doc)) {
char uuidBuf[100];
generate_uuid(uuidBuf, sizeof(uuidBuf), 0);
ws_xml_add_child(outHeaders, XML_NS_ADDRESSING, WSA_MESSAGE_ID, uuidBuf);
debug("Adding message id: %s", uuidBuf);
}
if (in_doc != NULL) {
WsXmlNodeH inMsgIdNode;
inMsgIdNode = wsman_get_soap_header_element(in_doc,XML_NS_ADDRESSING,
WSA_MESSAGE_ID);
if (inMsgIdNode != NULL &&
!ws_xml_get_child(outHeaders, 0, XML_NS_ADDRESSING, WSA_RELATES_TO)) {
ws_xml_add_child(outHeaders, XML_NS_ADDRESSING, WSA_RELATES_TO,
ws_xml_get_node_text(inMsgIdNode));
}
}
return 0;
}
/*
* Pre-save hook for saving a message in a blog room.
* (Do we want to only do this for top-level messages?)
*/
int blog_upload_beforesave(struct CtdlMessage *msg, recptypes *recp) {
/* Only run this hook for blog rooms */
if (CC->room.QRdefaultview != VIEW_BLOG) {
return(0);
}
/*
* If the message doesn't have an EUID, give it one.
*/
if (CM_IsEmpty(msg, eExclusiveID))
{
char uuid[SIZ];
generate_uuid(uuid);
CM_SetField(msg, eExclusiveID, uuid, strlen(uuid));
}
/*
* We also want to define a maximum length, whether we generated it or not.
*/
CM_CutFieldAt(msg, eExclusiveID, BLOG_EUIDBUF_SIZE - 1);
/* Now allow the save to complete. */
return(0);
}
static gboolean
glib_main (gpointer data)
{
xmlDoc *doc = NULL;
xmlNode *root_element = NULL;
struct connection conn;
static struct start_network_data start_network_data;
if (!(start_network_data.client = nm_client_new()))
{
network_status (NULL, "Unable to connect to NetworkManager");
g_main_loop_quit (loop);
return FALSE;
}
g_timeout_add_seconds (2, do_timeout, &start_network_data);
start_network_data.should_quit = TRUE;
/*parse the file and get the DOM */
if( NULL == (doc = xmlReadFile(NETWORK_CONFIG, NULL, 0))) {
network_status (start_network_data.client, "error: Could not parse " NETWORK_CONFIG "\n");
g_main_loop_quit (loop);
return FALSE;
}
/*Get the root element node */
root_element = xmlDocGetRootElement(doc);
if (root_element->type == XML_ELEMENT_NODE && !strcmp((char *)root_element->name, "configuration")) {
gchar *err = read_connection(&conn, root_element);
if (err) {
gchar err2[1024];
g_snprintf(err2, sizeof(err2), "Unable to parse configuration data: %s", err);
network_status (start_network_data.client, err2);
g_main_loop_quit (loop);
return FALSE;
}
}
else {
network_status (start_network_data.client, "error: Invalid " NETWORK_CONFIG " file: No <configuration/> root node\n");
g_main_loop_quit (loop);
return FALSE;
}
xmlFreeDoc(doc);
xmlCleanupParser();
/* Generate the UUID from the connection information */
generate_uuid(&conn, start_network_data.uuid, sizeof(start_network_data.uuid));
/* Hand control over to do_connection. Execution will continue in callbacks. */
do_connection(&start_network_data);
return FALSE;
}
/*
* Constructs a new bot with the specified username.
*/
player_bot::player_bot (server& srv, const std::string& username)
: username (username),
living_entity (srv)
{
this->uuid = generate_uuid ();
this->bbox = bounding_box {
vector3 (-(this->get_width () / 2.0), -(this->get_height () / 2.0), -(this->get_depth () / 2.0)),
vector3 (this->get_width () / 2.0, this->get_height () / 2.0, this->get_depth () / 2.0) };
this->ticks = 0;
}
/**
* Generates a pair record plist with required certificates for a specific
* device. If a pairing exists, it is loaded from the computer instead of being
* generated.
*
* @param pair_record_plist Holds the pair record.
*
* @return LOCKDOWN_E_SUCCESS on success
*/
static lockdownd_error_t pair_record_generate(lockdownd_client_t client, plist_t *pair_record)
{
lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
key_data_t public_key = { NULL, 0 };
char* host_id = NULL;
char* system_buid = NULL;
/* retrieve device public key */
ret = lockdownd_get_device_public_key_as_key_data(client, &public_key);
if (ret != LOCKDOWN_E_SUCCESS) {
debug_info("device refused to send public key.");
goto leave;
}
debug_info("device public key follows:\n%.*s", public_key.size, public_key.data);
*pair_record = plist_new_dict();
/* generate keys and certificates into pair record */
userpref_error_t uret = USERPREF_E_SUCCESS;
uret = pair_record_generate_keys_and_certs(*pair_record, public_key);
switch(uret) {
case USERPREF_E_INVALID_ARG:
ret = LOCKDOWN_E_INVALID_ARG;
break;
case USERPREF_E_INVALID_CONF:
ret = LOCKDOWN_E_INVALID_CONF;
break;
case USERPREF_E_SSL_ERROR:
ret = LOCKDOWN_E_SSL_ERROR;
default:
break;
}
/* set SystemBUID */
userpref_read_system_buid(&system_buid);
if (system_buid) {
plist_dict_set_item(*pair_record, USERPREF_SYSTEM_BUID_KEY, plist_new_string(system_buid));
}
/* set HostID */
host_id = generate_uuid();
pair_record_set_host_id(*pair_record, host_id);
leave:
if (host_id)
free(host_id);
if (system_buid)
free(system_buid);
if (public_key.data)
free(public_key.data);
return ret;
}
Object* Object::instantiate(Class *c) {
if (c == NULL) {
throw std::string("object.cpp: Cannot instantiate null class.");
}
Object* o = new Object();
o->isa = c;
o->id = generate_uuid(10);
return o;
}
//-----------------------------------------------------------------------------
bool worker_c::create_experiment( Reveal::Core::authorization_ptr auth, Reveal::Core::scenario_ptr scenario, Reveal::Core::experiment_ptr& experiment ) {
Reveal::DB::database_c::error_e db_error;
//experiment = Reveal::Core::experiment_ptr( new Reveal::Core::experiment_c() );
experiment->experiment_id = generate_uuid();
experiment->session_id = auth->get_session();
//TODO: validate that experiment values within bounds of scenario
db_error = _db->insert( experiment );
if( db_error == Reveal::DB::database_c::ERROR_NONE )
return true;
return false;
}
static void
test_change_databases (void)
{
char *dbname;
gint i;
GError *error = NULL;
dbname = generate_uuid ();
g_assert (dbname != NULL);
/* Database name can not start with a digit
* we will overwrite the first character with 'a' */
dbname[0] = 'a';
/* Create database */
couchdb_session_create_database (couchdb, dbname, &error);
if (error) {
g_critical ("Error creating database '%s': %s", dbname, error->message);
g_error_free (error);
}
couchdb_session_listen_for_changes (couchdb, dbname);
/* Create some documents */
for (i = 0; i < 10; i++) {
CouchdbDocument *document;
char *str;
document = couchdb_document_new (couchdb);
g_assert (document != NULL);
couchdb_document_set_boolean_field (document, "boolean", TRUE);
couchdb_document_set_int_field (document, "int", i);
couchdb_document_set_double_field (document, "double", (gdouble) i);
str = g_strdup_printf ("value%d", i);
couchdb_document_set_string_field (document, "string", str);
g_free (str);
g_assert (couchdb_document_put (document, dbname, &error));
g_assert (error == NULL);
}
/* Delete database */
g_assert (couchdb_session_delete_database (couchdb, dbname, &error));
g_assert (error == NULL);
/* Free memory */
g_free (dbname);
}
/*
* Create a new note
*/
void add_new_note(void) {
struct vnote *v;
v = vnote_new();
if (v) {
v->uid = malloc(128);
generate_uuid(v->uid);
v->color_red = pastel_palette[3][0];
v->color_green = pastel_palette[3][1];
v->color_blue = pastel_palette[3][2];
v->body = strdup(_("Click on any note to edit it."));
write_vnote_to_server(v);
vnote_free(v);
}
readloop(readfwd, eUseDefault);
}
/**
* Initialize super sector.
*
* @super_sect super sector image to initialize.
* @lbs logical block size.
* @pbs physical block size.
* @ddev_lb device size [logical block].
* @ldev_lb log device size [logical block]
* @name name of the walb device, or NULL.
*
* RETURN:
* true in success.
*/
bool init_super_sector_raw(
struct walb_super_sector* super_sect,
unsigned int lbs, unsigned int pbs,
u64 ddev_lb, u64 ldev_lb,
const char *name)
{
u32 salt;
char *rname;
bool ret;
ASSERT(super_sect);
ASSERT(0 < lbs);
ASSERT(0 < pbs);
ASSERT(0 < ddev_lb);
ASSERT(0 < ldev_lb);
ASSERT(sizeof(struct walb_super_sector) <= (size_t)pbs);
/* Prepare super sector */
memset(super_sect, 0, sizeof(*super_sect));
/* Set sector type. */
super_sect->sector_type = SECTOR_TYPE_SUPER;
/* Fill parameters. */
super_sect->version = WALB_LOG_VERSION;
super_sect->logical_bs = lbs;
super_sect->physical_bs = pbs;
super_sect->metadata_size = 0; /* currently fixed */
ret = generate_uuid(super_sect->uuid);
if (!ret) { return false; }
memset_random((u8 *)&salt, sizeof(salt));
LOGn("salt: %"PRIu32"\n", salt);
super_sect->log_checksum_salt = salt;
super_sect->ring_buffer_size =
ldev_lb / (pbs / lbs)
- get_ring_buffer_offset(pbs);
super_sect->oldest_lsid = 0;
super_sect->written_lsid = 0;
super_sect->device_size = ddev_lb;
rname = set_super_sector_name(super_sect, name);
if (name && strlen(name) != strlen(rname)) {
printf("name %s is pruned to %s.\n", name, rname);
}
ASSERT(is_valid_super_sector_raw(super_sect, pbs));
return true;
}
int main(int argc, char **argv)
{
alexjlz_log(1, "client started:%s\n", uuid);
generate_uuid();
alexjlz_log(1, "uuid generated:%s\n", uuid);
getOurIP();
srand(time(NULL) ^ getpid());
init_rand(time(NULL) ^ getpid());
set_proc_title(argc, argv, PROC_TITLE);
alexjlz_log(1, "set proc title success\n");
while (1)
{
if ( daemonize() == 0 )
break;
alexjlz_log(3, "daemonize failed\n");
sleep(3);
}
alexjlz_log(3, "daemonize success\n");
while ( 1 )
{
if( (mainCommSock=connect_tcp_server(server, port)) == -1)
{
alexjlz_log(3, "connect to server failed\n");
sleep(5);
continue;
}
alexjlz_log(3, "connect to server success\n");
if ( ask_for_service( mainCommSock ) == -1 ) // return from this function means connection between client
// and server are unexpectedly closed
{
//fprintf(stdout, "error in client\n");
}
if ( check_fd(mainCommSock) )
{
close(mainCommSock);
}
sleep(3);
}
return 0;
}
/* This constructor registers with the given registrant. It may block for a short
time. */
registrant_t(
mailbox_manager_t *mm,
const registrar_business_card_t<business_card_t> &rmd,
business_card_t initial_value) :
mailbox_manager(mm),
registrar_md(rmd),
registration_id(generate_uuid())
{
/* This will make it so that we get deregistered in our destructor. */
deregisterer.fun = std::bind(®istrant_t::send_deregister_message,
mailbox_manager,
registrar_md.delete_mailbox,
registration_id);
/* Send a message to register us */
send(mailbox_manager, registrar_md.create_mailbox,
registration_id,
mailbox_manager->get_connectivity_cluster()->get_me(),
initial_value);
}
/**
* couchdb_document_contact_address_new:
* @uuid: A unique ID
* @street: Street
* @ext_street: Extra information for the street
* @city: City
* @state: State or region
* @country: Country
* @postalcode: Postal code
* @pobox: Post Office box
* @description: Description for thos address
*
* Returns a #CouchdbStructField representing the given address.
*
* Returns: (transfer full): A newly-created #CouchdbStructField representing
* the given address information.
*/
CouchdbStructField *
couchdb_document_contact_address_new (const char *uuid,
const char *street,
const char *ext_street,
const char *city,
const char *state,
const char *country,
const char *postalcode,
const char *pobox,
const char *description)
{
CouchdbStructField *sf;
sf = couchdb_struct_field_new_from_json_object (json_object_new ());
if (uuid != NULL)
couchdb_struct_field_set_uuid (sf, uuid);
else {
char *new_uuid = generate_uuid ();
couchdb_struct_field_set_uuid (sf, new_uuid);
g_free (new_uuid);
}
if (street)
couchdb_document_contact_address_set_street (sf, street);
if (ext_street)
couchdb_document_contact_address_set_ext_street (sf, ext_street);
if (city)
couchdb_document_contact_address_set_city (sf, city);
if (state)
couchdb_document_contact_address_set_state (sf, state);
if (country)
couchdb_document_contact_address_set_country (sf, country);
if (postalcode)
couchdb_document_contact_address_set_postalcode (sf, postalcode);
if (pobox)
couchdb_document_contact_address_set_pobox (sf, pobox);
if (description)
couchdb_document_contact_address_set_description (sf, description);
return sf;
}
int pubnub_publishStatus(char *p_data){
enum pubnub_res res;
char const *chan = "sensorStatus-resp";
pubnub_t *pbp = pubnub_alloc();
if (NULL == pbp) {
printf("Failed to allocate Pubnub context!\n");
return -1;
}
pubnub_init(pbp, g_pub_key,g_sub_key);
pubnub_set_transaction_timeout(pbp, PUBNUB_DEFAULT_NON_SUBSCRIBE_TIMEOUT);
/* Leave this commented out to use the default - which is
blocking I/O on most platforms. Uncomment to use non-
blocking I/O.
*/
// pubnub_set_non_blocking_io(pbp);
generate_uuid(pbp);
pubnub_set_auth(pbp, "danaske");
res = pubnub_publish(pbp, chan, p_data);
if (res != PNR_STARTED) {
printf("pubnub_publish() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
//printf("Published! Response from Pubnub: %s\n", pubnub_last_publish_result(pbp));
}
else if (PNR_PUBLISH_FAILED == res) {
printf("Published failed on Pubnub, description: %s\n", pubnub_last_publish_result(pbp));
}
else {
printf("Publishing failed with code: %d\n", res);
}
return 0;
}
CouchdbStructField *
desktopcouch_document_contact_email_new (const char *uuid, const char *address, const char *description)
{
CouchdbStructField *sf;
sf = couchdb_struct_field_new_from_json_object (json_object_new ());
if (uuid != NULL)
couchdb_struct_field_set_uuid (sf, uuid);
else {
char *new_uuid = generate_uuid ();
couchdb_struct_field_set_uuid (sf, new_uuid);
g_free (new_uuid);
}
if (address)
desktopcouch_document_contact_email_set_address (sf, address);
if (description)
desktopcouch_document_contact_email_set_description (sf, description);
return sf;
}
//-----------------------------------------------------------------------------
bool worker_c::create_session( Reveal::Core::authorization_ptr auth, Reveal::Core::session_ptr& session ) {
Reveal::DB::database_c::error_e db_error;
session = Reveal::Core::session_ptr( new Reveal::Core::session_c() );
session->session_id = generate_uuid();
Reveal::Core::authorization_c::type_e type = auth->get_type();
if( type == Reveal::Core::authorization_c::TYPE_IDENTIFIED ) {
session->user_type = Reveal::Core::session_c::IDENTIFIED;
session->user_id = auth->get_user();
} else if( type == Reveal::Core::authorization_c::TYPE_ANONYMOUS ) {
session->user_type = Reveal::Core::session_c::ANONYMOUS;
session->user_id = "";
}
db_error = _db->insert( session );
if( db_error == Reveal::DB::database_c::ERROR_NONE )
return true;
return false;
}
/**
* couchdb_document_contact_phone_new:
* @uuid: A unique ID
* @number: A phone number
* @description: Description for this phone number
* @priority: Priority of this phone number
*
* Returns a #CouchdbStructField representing the given phone number.
*
* Returns: (transfer full): A newly-created #CouchdbStructField representing
* the given phone number information.
*/
CouchdbStructField *
couchdb_document_contact_phone_new (const char *uuid, const char *number, const char *description, gint priority)
{
CouchdbStructField *sf;
sf = couchdb_struct_field_new_from_json_object (json_object_new ());
if (uuid != NULL)
couchdb_struct_field_set_uuid (sf, uuid);
else {
char *new_uuid = generate_uuid ();
couchdb_struct_field_set_uuid (sf, new_uuid);
g_free (new_uuid);
}
if (number)
couchdb_document_contact_phone_set_number (sf, number);
if (description)
couchdb_document_contact_phone_set_description (sf, description);
couchdb_document_contact_phone_set_priority (sf, priority);
return sf;
}
int main()
{
char const *msg;
enum pubnub_res res;
char const *chan = "hello_world";
pubnub_t *pbp = pubnub_alloc();
if (NULL == pbp) {
printf("Failed to allocate Pubnub context!\n");
return -1;
}
pubnub_init(pbp, "demo", "demo");
pubnub_set_transaction_timeout(pbp, PUBNUB_DEFAULT_NON_SUBSCRIBE_TIMEOUT);
/* Leave this commented out to use the default - which is
blocking I/O on most platforms. Uncomment to use non-
blocking I/O.
*/
// pubnub_set_non_blocking_io(pbp);
generate_uuid(pbp);
pubnub_set_auth(pbp, "danaske");
puts("Publishing...");
res = pubnub_publish(pbp, chan, "\"Hello world from sync!\"");
if (res != PNR_STARTED) {
printf("pubnub_publish() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
printf("Published! Response from Pubnub: %s\n", pubnub_last_publish_result(pbp));
}
else if (PNR_PUBLISH_FAILED == res) {
printf("Published failed on Pubnub, description: %s\n", pubnub_last_publish_result(pbp));
}
else {
printf("Publishing failed with code: %d\n", res);
}
puts("Subscribing...");
res = pubnub_subscribe(pbp, chan, NULL);
if (res != PNR_STARTED) {
printf("pubnub_subscribe() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
puts("Subscribed!");
}
else {
printf("Subscribing failed with code: %d\n", res);
}
res = pubnub_subscribe(pbp, chan, NULL);
if (res != PNR_STARTED) {
printf("pubnub_subscribe() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
puts("Subscribed! Got messages:");
for (;;) {
msg = pubnub_get(pbp);
if (NULL == msg) {
break;
}
puts(msg);
}
}
else {
printf("Subscribing failed with code: %d\n", res);
}
puts("Getting time...");
res = pubnub_time(pbp);
if (res != PNR_STARTED) {
printf("pubnub_time() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
printf("Gotten time: %s; last time token=%s\n", pubnub_get(pbp), pubnub_last_time_token(pbp));
}
else {
printf("Getting time failed with code: %d\n", res);
}
puts("Getting history with include_token...");
res = pubnub_history(pbp, chan, 10, true);
if (res != PNR_STARTED) {
printf("pubnub_history() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
puts("Got history! Elements:");
for (;;) {
msg = pubnub_get(pbp);
if (NULL == msg) {
break;
}
puts(msg);
}
}
else {
printf("Getting history v2 with include_token failed with code: %d\n", res);
}
puts("Getting here_now presence...");
res = pubnub_here_now(pbp, chan, NULL);
if (res != PNR_STARTED) {
printf("pubnub_here_now() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
puts("Got here now presence!");
for (;;) {
msg = pubnub_get(pbp);
if (NULL == msg) {
break;
}
puts(msg);
}
}
else {
printf("Getting here-now presence failed with code: %d\n", res);
}
/** Global here_now presence for "demo" subscribe key is _very_
long, but we have it here to show that we can handle very long
response if the PUBNUB_DYNAMIC_REPLY_BUFFER is "on".
*/
if (PUBNUB_DYNAMIC_REPLY_BUFFER) {
puts("Getting global here_now presence...");
res = pubnub_global_here_now(pbp);
if (res != PNR_STARTED) {
printf("pubnub_global_here_now() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
puts("Got global here now presence!");
for (;;) {
msg = pubnub_get(pbp);
if (NULL == msg) {
break;
}
puts(msg);
}
}
else {
printf("Getting global here-now presence failed with code: %d\n", res);
}
}
puts("Getting where_now presence...");
res = pubnub_where_now(pbp, pubnub_uuid_get(pbp));
if (res != PNR_STARTED) {
printf("pubnub_where_now() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
puts("Got where now presence!");
for (;;) {
msg = pubnub_get(pbp);
if (NULL == msg) {
break;
}
puts(msg);
}
}
else {
printf("Getting where-now presence failed with code: %d\n", res);
}
puts("Setting state...");
res = pubnub_set_state(pbp, chan, NULL, pubnub_uuid_get(pbp), "{\"x\":5}");
if (res != PNR_STARTED) {
printf("pubnub_set_state() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
puts("Got set state response!");
for (;;) {
msg = pubnub_get(pbp);
if (NULL == msg) {
break;
}
puts(msg);
}
}
else {
printf("Setting state failed with code: %d\n", res);
}
puts("Getting state...");
res = pubnub_state_get(pbp, chan, NULL, pubnub_uuid_get(pbp));
if (res != PNR_STARTED) {
printf("pubnub_state_get() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
puts("Got state!");
for (;;) {
msg = pubnub_get(pbp);
if (NULL == msg) {
break;
}
puts(msg);
}
}
else {
printf("Getting state failed with code: %d\n", res);
}
puts("List channel group...");
res = pubnub_list_channel_group(pbp, "channel-group");
if (res != PNR_STARTED) {
printf("pubnub_state_get() returned unexpected: %d\n", res);
pubnub_free(pbp);
return -1;
}
res = pubnub_await(pbp);
if (res == PNR_STARTED) {
printf("pubnub_await() returned unexpected: PNR_STARTED(%d)\n", res);
pubnub_free(pbp);
return -1;
}
if (PNR_OK == res) {
puts("Got channel group list!");
for (;;) {
msg = pubnub_get_channel(pbp);
if (NULL == msg) {
break;
}
puts(msg);
}
}
else {
printf("Getting channel group list failed with code: %d ('%s')\n", res, pubnub_res_2_string(res));
}
/* We're done */
if (pubnub_free(pbp) != 0) {
printf("Failed to free the Pubnub context\n");
}
puts("Pubnub sync demo over.");
return 0;
}
static int
glusterfs_ctx_defaults_init (glusterfs_ctx_t *ctx)
{
cmd_args_t *cmd_args = NULL;
struct rlimit lim = {0, };
call_pool_t *pool = NULL;
xlator_mem_acct_init (THIS, gfd_mt_end);
ctx->process_uuid = generate_uuid ();
if (!ctx->process_uuid)
return -1;
ctx->page_size = 128 * GF_UNIT_KB;
ctx->iobuf_pool = iobuf_pool_new (8 * GF_UNIT_MB, ctx->page_size);
if (!ctx->iobuf_pool)
return -1;
ctx->event_pool = event_pool_new (DEFAULT_EVENT_POOL_SIZE);
if (!ctx->event_pool)
return -1;
pool = GF_CALLOC (1, sizeof (call_pool_t),
gfd_mt_call_pool_t);
if (!pool)
return -1;
/* frame_mem_pool size 112 * 16k */
pool->frame_mem_pool = mem_pool_new (call_frame_t, 16384);
if (!pool->frame_mem_pool)
return -1;
/* stack_mem_pool size 256 * 8k */
pool->stack_mem_pool = mem_pool_new (call_stack_t, 8192);
if (!pool->stack_mem_pool)
return -1;
ctx->stub_mem_pool = mem_pool_new (call_stub_t, 1024);
if (!ctx->stub_mem_pool)
return -1;
INIT_LIST_HEAD (&pool->all_frames);
LOCK_INIT (&pool->lock);
ctx->pool = pool;
pthread_mutex_init (&(ctx->lock), NULL);
cmd_args = &ctx->cmd_args;
/* parsing command line arguments */
cmd_args->log_level = DEFAULT_LOG_LEVEL;
#ifdef GF_DARWIN_HOST_OS
cmd_args->mac_compat = GF_OPTION_DEFERRED;
/* On Darwin machines, O_APPEND is not handled,
* which may corrupt the data
*/
cmd_args->fuse_direct_io_mode = GF_OPTION_DISABLE;
#else
cmd_args->mac_compat = GF_OPTION_DISABLE;
cmd_args->fuse_direct_io_mode = GF_OPTION_DEFERRED;
#endif
cmd_args->fuse_attribute_timeout = -1;
cmd_args->fuse_entry_timeout = -1;
INIT_LIST_HEAD (&cmd_args->xlator_options);
lim.rlim_cur = RLIM_INFINITY;
lim.rlim_max = RLIM_INFINITY;
setrlimit (RLIMIT_CORE, &lim);
return 0;
}
char *process_uuid(struct Logs *logs,
const struct Rc *rc, const struct Options *opt,
struct Entry *entry)
{
assert(logs);
assert(logs->logfp);
assert(rc);
assert(opt);
assert(entry);
/*
* Generate the UUID or use an already generated UUID stored in
* opt->uuid.
*/
if (opt->uuid) {
if (!valid_uuid(opt->uuid, TRUE)) {
fprintf(stderr, "process_uuid(): UUID \"%s\" is not "
"valid.\n", opt->uuid);
return NULL;
}
entry->uuid = opt->uuid;
} else
entry->uuid = generate_uuid(rc, opt->random_mac);
if (!entry->uuid) {
fprintf(stderr, "%s: UUID generation failed\n", progname);
return NULL;
}
/*
* Extract the time stamp from the UUID and store it in an allocated
* buffer.
*/
if (!entry->date)
entry->date = malloc(DATE_LENGTH + 1);
if (!entry->date) {
myerror("process_uuid(): Could not allocate %lu bytes for "
"date string", DATE_LENGTH + 1);
return NULL;
}
if (!uuid_date_from_uuid(entry->date, entry->uuid))
return NULL;
if (add_to_logfile(logs->logfp, entry, opt->raw) == EXIT_FAILURE)
return NULL;
/*
* Write the UUID to stdout and/or stderr, or not, depending on the
* -w/--whereto argument.
*/
if (!opt->whereto)
puts(entry->uuid);
else {
if (strchr(opt->whereto, 'a') || strchr(opt->whereto, 'o'))
fprintf(stdout, "%s\n", entry->uuid);
if (strchr(opt->whereto, 'a') || strchr(opt->whereto, 'e'))
fprintf(stderr, "%s\n", entry->uuid);
}
return entry->uuid;
}
static order_bucket_t create() { return order_bucket_t(generate_uuid()); }
/* Fill in the superblock memory buffer based on the filesystem parameters */
void ext4_fill_in_sb()
{
unsigned int i;
struct ext4_super_block *sb = aux_info.sb;
sb->s_inodes_count = info.inodes_per_group * aux_info.groups;
sb->s_blocks_count_lo = aux_info.len_blocks;
sb->s_r_blocks_count_lo = 0;
sb->s_free_blocks_count_lo = 0;
sb->s_free_inodes_count = 0;
sb->s_first_data_block = aux_info.first_data_block;
sb->s_log_block_size = log_2(info.block_size / 1024);
sb->s_obso_log_frag_size = log_2(info.block_size / 1024);
sb->s_blocks_per_group = info.blocks_per_group;
sb->s_obso_frags_per_group = info.blocks_per_group;
sb->s_inodes_per_group = info.inodes_per_group;
sb->s_mtime = 0;
sb->s_wtime = 0;
sb->s_mnt_count = 0;
sb->s_max_mnt_count = 0xFFFF;
sb->s_magic = EXT4_SUPER_MAGIC;
sb->s_state = EXT4_VALID_FS;
sb->s_errors = EXT4_ERRORS_RO;
sb->s_minor_rev_level = 0;
sb->s_lastcheck = 0;
sb->s_checkinterval = 0;
sb->s_creator_os = EXT4_OS_LINUX;
sb->s_rev_level = EXT4_DYNAMIC_REV;
sb->s_def_resuid = EXT4_DEF_RESUID;
sb->s_def_resgid = EXT4_DEF_RESGID;
sb->s_first_ino = EXT4_GOOD_OLD_FIRST_INO;
sb->s_inode_size = info.inode_size;
sb->s_block_group_nr = 0;
sb->s_feature_compat = info.feat_compat;
sb->s_feature_incompat = info.feat_incompat;
sb->s_feature_ro_compat = info.feat_ro_compat;
generate_uuid("extandroid/make_ext4fs", info.label, sb->s_uuid);
memset(sb->s_volume_name, 0, sizeof(sb->s_volume_name));
strncpy(sb->s_volume_name, info.label, sizeof(sb->s_volume_name));
memset(sb->s_last_mounted, 0, sizeof(sb->s_last_mounted));
sb->s_algorithm_usage_bitmap = 0;
sb->s_reserved_gdt_blocks = info.bg_desc_reserve_blocks;
sb->s_prealloc_blocks = 0;
sb->s_prealloc_dir_blocks = 0;
//memcpy(sb->s_journal_uuid, sb->s_uuid, sizeof(sb->s_journal_uuid));
if (info.feat_compat & EXT4_FEATURE_COMPAT_HAS_JOURNAL)
sb->s_journal_inum = EXT4_JOURNAL_INO;
sb->s_journal_dev = 0;
sb->s_last_orphan = 0;
sb->s_hash_seed[0] = 0; /* FIXME */
sb->s_def_hash_version = DX_HASH_TEA;
sb->s_reserved_char_pad = EXT4_JNL_BACKUP_BLOCKS;
sb->s_desc_size = sizeof(struct ext2_group_desc);
sb->s_default_mount_opts = 0; /* FIXME */
sb->s_first_meta_bg = 0;
sb->s_mkfs_time = 0;
//sb->s_jnl_blocks[17]; /* FIXME */
sb->s_blocks_count_hi = aux_info.len_blocks >> 32;
sb->s_r_blocks_count_hi = 0;
sb->s_free_blocks_count_hi = 0;
sb->s_min_extra_isize = sizeof(struct ext4_inode) -
EXT4_GOOD_OLD_INODE_SIZE;
sb->s_want_extra_isize = sizeof(struct ext4_inode) -
EXT4_GOOD_OLD_INODE_SIZE;
sb->s_flags = 0;
sb->s_raid_stride = 0;
sb->s_mmp_interval = 0;
sb->s_mmp_block = 0;
sb->s_raid_stripe_width = 0;
sb->s_log_groups_per_flex = 0;
sb->s_kbytes_written = 0;
for (i = 0; i < aux_info.groups; i++) {
u64 group_start_block = aux_info.first_data_block + i *
info.blocks_per_group;
u32 header_size = 0;
if (ext4_bg_has_super_block(i)) {
if (i != 0) {
aux_info.backup_sb[i] = calloc(info.block_size, 1);
memcpy(aux_info.backup_sb[i], sb, info.block_size);
/* Update the block group nr of this backup superblock */
aux_info.backup_sb[i]->s_block_group_nr = i;
queue_data_block((u8 *)aux_info.backup_sb[i],
info.block_size, group_start_block);
}
queue_data_block((u8 *)aux_info.bg_desc,
aux_info.bg_desc_blocks * info.block_size,
group_start_block + 1);
header_size = 1 + aux_info.bg_desc_blocks + info.bg_desc_reserve_blocks;
}
aux_info.bg_desc[i].bg_block_bitmap = group_start_block + header_size;
aux_info.bg_desc[i].bg_inode_bitmap = group_start_block + header_size + 1;
aux_info.bg_desc[i].bg_inode_table = group_start_block + header_size + 2;
aux_info.bg_desc[i].bg_free_blocks_count = sb->s_blocks_per_group;
aux_info.bg_desc[i].bg_free_inodes_count = sb->s_inodes_per_group;
aux_info.bg_desc[i].bg_used_dirs_count = 0;
}
}
LIBIMOBILEDEVICE_API lockdownd_error_t lockdownd_client_new(idevice_t device, lockdownd_client_t *client, const char *label)
{
if (!client)
return LOCKDOWN_E_INVALID_ARG;
static struct lockdownd_service_descriptor service = {
.port = 0xf27e,
.ssl_enabled = 0
};
property_list_service_client_t plistclient = NULL;
if (property_list_service_client_new(device, (lockdownd_service_descriptor_t)&service, &plistclient) != PROPERTY_LIST_SERVICE_E_SUCCESS) {
debug_info("could not connect to lockdownd (device %s)", device->udid);
return LOCKDOWN_E_MUX_ERROR;
}
lockdownd_client_t client_loc = (lockdownd_client_t) malloc(sizeof(struct lockdownd_client_private));
client_loc->parent = plistclient;
client_loc->ssl_enabled = 0;
client_loc->session_id = NULL;
if (idevice_get_udid(device, &client_loc->udid) != IDEVICE_E_SUCCESS) {
debug_info("failed to get device udid.");
}
debug_info("device udid: %s", client_loc->udid);
client_loc->label = label ? strdup(label) : NULL;
*client = client_loc;
return LOCKDOWN_E_SUCCESS;
}
LIBIMOBILEDEVICE_API lockdownd_error_t lockdownd_client_new_with_handshake(idevice_t device, lockdownd_client_t *client, const char *label)
{
if (!client)
return LOCKDOWN_E_INVALID_ARG;
lockdownd_error_t ret = LOCKDOWN_E_SUCCESS;
lockdownd_client_t client_loc = NULL;
char *host_id = NULL;
char *type = NULL;
ret = lockdownd_client_new(device, &client_loc, label);
if (LOCKDOWN_E_SUCCESS != ret) {
debug_info("failed to create lockdownd client.");
return ret;
}
/* perform handshake */
if (LOCKDOWN_E_SUCCESS != lockdownd_query_type(client_loc, &type)) {
debug_info("QueryType failed in the lockdownd client.");
ret = LOCKDOWN_E_NOT_ENOUGH_DATA;
} else {
if (strcmp("com.apple.mobile.lockdown", type)) {
debug_info("Warning QueryType request returned \"%s\".", type);
}
}
if (type)
free(type);
plist_t pair_record = NULL;
userpref_read_pair_record(client_loc->udid, &pair_record);
if (pair_record) {
pair_record_get_host_id(pair_record, &host_id);
}
if (LOCKDOWN_E_SUCCESS == ret && !host_id) {
ret = LOCKDOWN_E_INVALID_CONF;
}
if (LOCKDOWN_E_SUCCESS == ret && !pair_record) {
/* attempt pairing */
ret = lockdownd_pair(client_loc, NULL);
}
plist_free(pair_record);
pair_record = NULL;
/* in any case, we need to validate pairing to receive trusted host status */
ret = lockdownd_validate_pair(client_loc, NULL);
/* if not paired yet, let's do it now */
if (LOCKDOWN_E_INVALID_HOST_ID == ret) {
ret = lockdownd_pair(client_loc, NULL);
if (LOCKDOWN_E_SUCCESS == ret) {
ret = lockdownd_validate_pair(client_loc, NULL);
} else if (LOCKDOWN_E_PAIRING_DIALOG_PENDING == ret) {
debug_info("Device shows the pairing dialog.");
}
}
if (LOCKDOWN_E_SUCCESS == ret) {
if (!host_id) {
userpref_read_pair_record(client_loc->udid, &pair_record);
if (pair_record) {
pair_record_get_host_id(pair_record, &host_id);
plist_free(pair_record);
}
}
ret = lockdownd_start_session(client_loc, host_id, NULL, NULL);
if (LOCKDOWN_E_SUCCESS != ret) {
debug_info("Session opening failed.");
}
if (host_id) {
free(host_id);
host_id = NULL;
}
}
if (LOCKDOWN_E_SUCCESS == ret) {
*client = client_loc;
} else {
lockdownd_client_free(client_loc);
}
return ret;
}
/**
* Returns a new plist from the supplied lockdownd pair record. The caller is
* responsible for freeing the plist.
*
* @param pair_record The pair record to create a plist from.
*
* @return A pair record plist from the device, NULL if pair_record is not set
*/
static plist_t lockdownd_pair_record_to_plist(lockdownd_pair_record_t pair_record)
{
if (!pair_record)
return NULL;
/* setup request plist */
plist_t dict = plist_new_dict();
plist_dict_set_item(dict, "DeviceCertificate", plist_new_data(pair_record->device_certificate, strlen(pair_record->device_certificate)));
plist_dict_set_item(dict, "HostCertificate", plist_new_data(pair_record->host_certificate, strlen(pair_record->host_certificate)));
plist_dict_set_item(dict, "HostID", plist_new_string(pair_record->host_id));
plist_dict_set_item(dict, "RootCertificate", plist_new_data(pair_record->root_certificate, strlen(pair_record->root_certificate)));
plist_dict_set_item(dict, "SystemBUID", plist_new_string(pair_record->system_buid));
return dict;
}
/**
* Generates a pair record plist with required certificates for a specific
* device. If a pairing exists, it is loaded from the computer instead of being
* generated.
*
* @param pair_record_plist Holds the pair record.
*
* @return LOCKDOWN_E_SUCCESS on success
*/
static lockdownd_error_t pair_record_generate(lockdownd_client_t client, plist_t *pair_record)
{
lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
key_data_t public_key = { NULL, 0 };
char* host_id = NULL;
char* system_buid = NULL;
/* retrieve device public key */
ret = lockdownd_get_device_public_key_as_key_data(client, &public_key);
if (ret != LOCKDOWN_E_SUCCESS) {
debug_info("device refused to send public key.");
goto leave;
}
debug_info("device public key follows:\n%.*s", public_key.size, public_key.data);
*pair_record = plist_new_dict();
/* generate keys and certificates into pair record */
userpref_error_t uret = USERPREF_E_SUCCESS;
uret = pair_record_generate_keys_and_certs(*pair_record, public_key);
switch(uret) {
case USERPREF_E_INVALID_ARG:
ret = LOCKDOWN_E_INVALID_ARG;
break;
case USERPREF_E_INVALID_CONF:
ret = LOCKDOWN_E_INVALID_CONF;
break;
case USERPREF_E_SSL_ERROR:
ret = LOCKDOWN_E_SSL_ERROR;
default:
break;
}
/* set SystemBUID */
userpref_read_system_buid(&system_buid);
if (system_buid) {
plist_dict_set_item(*pair_record, USERPREF_SYSTEM_BUID_KEY, plist_new_string(system_buid));
}
/* set HostID */
host_id = generate_uuid();
pair_record_set_host_id(*pair_record, host_id);
leave:
if (host_id)
free(host_id);
if (system_buid)
free(system_buid);
if (public_key.data)
free(public_key.data);
return ret;
}
struct device_desc *device_desc_new(config_options_t *options)
{
struct device_desc *d = calloc(1, sizeof(*d));
char *s = NULL;
if (!d)
return NULL;
if (options->uuid)
quote_xml_special(&d->uuid, options->uuid);
else
generate_uuid(&d->uuid);
if (options->serialNumber) {
quote_xml_special(&d->serialNumber, options->serialNumber);
} else {
deviceinfo_from_cpuinfo(&s, "Serial");
if (s) {
quote_xml_special(&d->serialNumber, s);
free(s);
s = NULL;
}
}
if (options->modelURL)
quote_xml_special(&d->modelURL, options->modelURL);
if (options->modelNumber)
quote_xml_special(&d->modelNumber, options->modelNumber);
if (options->modelDescription)
quote_xml_special(&d->modelDescription, options->modelDescription);
if (options->manufacturerURL) {
quote_xml_special(&d->manufacturerURL, options->manufacturerURL);
} else {
deviceinfo_from_deviceinfo(&s, "DEVICE_MANUFACTURER_URL");
if (s) {
quote_xml_special(&d->manufacturerURL, s);
free(s);
s = NULL;
}
}
if (options->manufacturer) {
quote_xml_special(&d->manufacturer, options->manufacturer);
} else {
deviceinfo_from_deviceinfo(&s, "DEVICE_MANUFACTURER");
if (s) {
quote_xml_special(&d->manufacturer, s);
free(s);
s = NULL;
}
}
if (options->modelName) {
quote_xml_special(&d->modelName, options->modelName);
} else {
deviceinfo_from_deviceinfo(&s, "DEVICE_PRODUCT");
if (s) {
quote_xml_special(&d->modelName, s);
free(s);
s = NULL;
}
}
if (options->friendlyName) {
quote_xml_special(&d->friendlyName, options->friendlyName);
} else {
deviceinfo_from_deviceinfo(&s, "DEVICE_FRIENDLYNAME");
if (s) {
quote_xml_special(&d->friendlyName, s);
free(s);
s = NULL;
} else {
if (d->manufacturer && d->manufacturer[0] &&
d->modelName && d->modelName[0]) {
asprintf(&s, "%s %s", d->manufacturer, d->modelName);
if (s) {
quote_xml_special(&d->friendlyName, s);
free(s);
s = NULL;
}
}
}
}
if (options->presentationURL) {
quote_xml_special(&d->presentationURL, options->presentationURL);
} else {
asprintf(&d->presentationURL, "http%s://%s/", options->use_https ? "s" : "",
UpnpGetServerIpAddress());
}
return d;
}
/*
* Before allowing a wiki page save to execute, we have to perform version control.
* This involves fetching the old version of the page if it exists.
*/
int wiki_upload_beforesave(struct CtdlMessage *msg, recptypes *recp) {
struct CitContext *CCC = CC;
long old_msgnum = (-1L);
struct CtdlMessage *old_msg = NULL;
long history_msgnum = (-1L);
struct CtdlMessage *history_msg = NULL;
char diff_old_filename[PATH_MAX];
char diff_new_filename[PATH_MAX];
char diff_out_filename[PATH_MAX];
char diff_cmd[PATH_MAX];
FILE *fp;
int rv;
char history_page[1024];
long history_page_len;
char boundary[256];
char prefixed_boundary[258];
char buf[1024];
char *diffbuf = NULL;
size_t diffbuf_len = 0;
char *ptr = NULL;
long newmsgid;
StrBuf *msgidbuf;
if (!CCC->logged_in) return(0); /* Only do this if logged in. */
/* Is this a room with a Wiki in it, don't run this hook. */
if ((CCC->room.QRdefaultview != VIEW_WIKI) &&
(CCC->room.QRdefaultview != VIEW_WIKIMD)) {
return(0);
}
/* If this isn't a MIME message, don't bother. */
if (msg->cm_format_type != 4) return(0);
/* If there's no EUID we can't do this. Reject the post. */
if (CM_IsEmpty(msg, eExclusiveID)) return(1);
newmsgid = get_new_message_number();
msgidbuf = NewStrBuf();
StrBufPrintf(msgidbuf, "%08lX-%08lX@%s/%s",
(long unsigned int) time(NULL),
(long unsigned int) newmsgid,
CtdlGetConfigStr("c_fqdn"),
msg->cm_fields[eExclusiveID]
);
CM_SetAsFieldSB(msg, emessageId, &msgidbuf);
history_page_len = snprintf(history_page, sizeof history_page,
"%s_HISTORY_", msg->cm_fields[eExclusiveID]);
/* Make sure we're saving a real wiki page rather than a wiki history page.
* This is important in order to avoid recursing infinitely into this hook.
*/
if ( (msg->cm_lengths[eExclusiveID] >= 9)
&& (!strcasecmp(&msg->cm_fields[eExclusiveID][msg->cm_lengths[eExclusiveID]-9], "_HISTORY_"))
) {
syslog(LOG_DEBUG, "History page not being historied\n");
return(0);
}
/* If there's no message text, obviously this is all b0rken and shouldn't happen at all */
if (CM_IsEmpty(msg, eMesageText)) return(0);
/* Set the message subject identical to the page name */
CM_CopyField(msg, eMsgSubject, eExclusiveID);
/* See if we can retrieve the previous version. */
old_msgnum = CtdlLocateMessageByEuid(msg->cm_fields[eExclusiveID], &CCC->room);
if (old_msgnum > 0L) {
old_msg = CtdlFetchMessage(old_msgnum, 1, 1);
}
else {
old_msg = NULL;
}
if ((old_msg != NULL) && (CM_IsEmpty(old_msg, eMesageText))) { /* old version is corrupt? */
CM_Free(old_msg);
old_msg = NULL;
}
/* If no changes were made, don't bother saving it again */
if ((old_msg != NULL) && (!strcmp(msg->cm_fields[eMesageText], old_msg->cm_fields[eMesageText]))) {
CM_Free(old_msg);
return(1);
}
/*
* Generate diffs
*/
CtdlMakeTempFileName(diff_old_filename, sizeof diff_old_filename);
CtdlMakeTempFileName(diff_new_filename, sizeof diff_new_filename);
CtdlMakeTempFileName(diff_out_filename, sizeof diff_out_filename);
if (old_msg != NULL) {
fp = fopen(diff_old_filename, "w");
rv = fwrite(old_msg->cm_fields[eMesageText], old_msg->cm_lengths[eMesageText], 1, fp);
fclose(fp);
CM_Free(old_msg);
}
fp = fopen(diff_new_filename, "w");
rv = fwrite(msg->cm_fields[eMesageText], msg->cm_lengths[eMesageText], 1, fp);
fclose(fp);
snprintf(diff_cmd, sizeof diff_cmd,
DIFF " -u %s %s >%s",
diff_new_filename,
((old_msg != NULL) ? diff_old_filename : "/dev/null"),
diff_out_filename
);
syslog(LOG_DEBUG, "diff cmd: %s", diff_cmd);
rv = system(diff_cmd);
syslog(LOG_DEBUG, "diff cmd returned %d", rv);
diffbuf_len = 0;
diffbuf = NULL;
fp = fopen(diff_out_filename, "r");
if (fp == NULL) {
fp = fopen("/dev/null", "r");
}
if (fp != NULL) {
fseek(fp, 0L, SEEK_END);
diffbuf_len = ftell(fp);
fseek(fp, 0L, SEEK_SET);
diffbuf = malloc(diffbuf_len + 1);
fread(diffbuf, diffbuf_len, 1, fp);
diffbuf[diffbuf_len] = '\0';
fclose(fp);
}
syslog(LOG_DEBUG, "diff length is "SIZE_T_FMT" bytes", diffbuf_len);
unlink(diff_old_filename);
unlink(diff_new_filename);
unlink(diff_out_filename);
/* Determine whether this was a bogus (empty) edit */
if ((diffbuf_len = 0) && (diffbuf != NULL)) {
free(diffbuf);
diffbuf = NULL;
}
if (diffbuf == NULL) {
return(1); /* No changes at all? Abandon the post entirely! */
}
/* Now look for the existing edit history */
history_msgnum = CtdlLocateMessageByEuid(history_page, &CCC->room);
history_msg = NULL;
if (history_msgnum > 0L) {
history_msg = CtdlFetchMessage(history_msgnum, 1, 1);
}
/* Create a new history message if necessary */
if (history_msg == NULL) {
char *buf;
long len;
history_msg = malloc(sizeof(struct CtdlMessage));
memset(history_msg, 0, sizeof(struct CtdlMessage));
history_msg->cm_magic = CTDLMESSAGE_MAGIC;
history_msg->cm_anon_type = MES_NORMAL;
history_msg->cm_format_type = FMT_RFC822;
CM_SetField(history_msg, eAuthor, HKEY("Citadel"));
if (!IsEmptyStr(CCC->room.QRname)){
CM_SetField(history_msg, eRecipient, CCC->room.QRname, strlen(CCC->room.QRname));
}
CM_SetField(history_msg, eExclusiveID, history_page, history_page_len);
CM_SetField(history_msg, eMsgSubject, history_page, history_page_len);
CM_SetField(history_msg, eSuppressIdx, HKEY("1")); /* suppress full text indexing */
snprintf(boundary, sizeof boundary, "Citadel--Multipart--%04x--%08lx", getpid(), time(NULL));
buf = (char*) malloc(1024);
len = snprintf(buf, 1024,
"Content-type: multipart/mixed; boundary=\"%s\"\n\n"
"This is a Citadel wiki history encoded as multipart MIME.\n"
"Each part is comprised of a diff script representing one change set.\n"
"\n"
"--%s--\n",
boundary, boundary
);
CM_SetAsField(history_msg, eMesageText, &buf, len);
}
/* Update the history message (regardless of whether it's new or existing) */
/* Remove the Message-ID from the old version of the history message. This will cause a brand
* new one to be generated, avoiding an uninitentional hit of the loop zapper when we replicate.
*/
CM_FlushField(history_msg, emessageId);
/* Figure out the boundary string. We do this even when we generated the
* boundary string in the above code, just to be safe and consistent.
*/
*boundary = '\0';
ptr = history_msg->cm_fields[eMesageText];
do {
ptr = memreadline(ptr, buf, sizeof buf);
if (*ptr != 0) {
striplt(buf);
if (!IsEmptyStr(buf) && (!strncasecmp(buf, "Content-type:", 13))) {
if (
(bmstrcasestr(buf, "multipart") != NULL)
&& (bmstrcasestr(buf, "boundary=") != NULL)
) {
safestrncpy(boundary, bmstrcasestr(buf, "\""), sizeof boundary);
char *qu;
qu = strchr(boundary, '\"');
if (qu) {
strcpy(boundary, ++qu);
}
qu = strchr(boundary, '\"');
if (qu) {
*qu = 0;
}
}
}
}
} while ( (IsEmptyStr(boundary)) && (*ptr != 0) );
/*
* Now look for the first boundary. That is where we need to insert our fun.
*/
if (!IsEmptyStr(boundary)) {
char *MsgText;
long MsgTextLen;
time_t Now = time(NULL);
snprintf(prefixed_boundary, sizeof(prefixed_boundary), "--%s", boundary);
CM_GetAsField(history_msg, eMesageText, &MsgText, &MsgTextLen);
ptr = bmstrcasestr(MsgText, prefixed_boundary);
if (ptr != NULL) {
StrBuf *NewMsgText;
char uuid[64];
char memo[512];
long memolen;
char encoded_memo[1024];
NewMsgText = NewStrBufPlain(NULL, MsgTextLen + diffbuf_len + 1024);
generate_uuid(uuid);
memolen = snprintf(memo, sizeof(memo), "%s|%ld|%s|%s",
uuid,
Now,
CCC->user.fullname,
CtdlGetConfigStr("c_nodename"));
memolen = CtdlEncodeBase64(encoded_memo, memo, memolen, 0);
StrBufAppendBufPlain(NewMsgText, HKEY("--"), 0);
StrBufAppendBufPlain(NewMsgText, boundary, -1, 0);
StrBufAppendBufPlain(
NewMsgText,
HKEY("\n"
"Content-type: text/plain\n"
"Content-Disposition: inline; filename=\""), 0);
StrBufAppendBufPlain(NewMsgText, encoded_memo, memolen, 0);
StrBufAppendBufPlain(
NewMsgText,
HKEY("\"\n"
"Content-Transfer-Encoding: 8bit\n"
"\n"), 0);
StrBufAppendBufPlain(NewMsgText, diffbuf, diffbuf_len, 0);
StrBufAppendBufPlain(NewMsgText, HKEY("\n"), 0);
StrBufAppendBufPlain(NewMsgText, ptr, MsgTextLen - (ptr - MsgText), 0);
free(MsgText);
CM_SetAsFieldSB(history_msg, eMesageText, &NewMsgText);
}
else
{
CM_SetAsField(history_msg, eMesageText, &MsgText, MsgTextLen);
}
CM_SetFieldLONG(history_msg, eTimestamp, Now);
CtdlSubmitMsg(history_msg, NULL, "", 0);
}
else {
syslog(LOG_ALERT, "Empty boundary string in history message. No history!\n");
}
free(diffbuf);
CM_Free(history_msg);
return(0);
}
