int try_open_new_listening_sockets (struct mc_config *MC) {
int i, j, sfd;
for (i = 0; i < MC->clusters_num; i++) {
if (MC->Clusters[i].other_cluster_no >= 0) {
continue;
}
sfd = server_socket (MC->Clusters[i].port, settings_addr, backlog, 0);
if (sfd >= MAX_CONNECTIONS) {
vkprintf (0, "cannot open server socket at port %d: too many open connections (fd=%d)\n", MC->Clusters[i].port, sfd);
close (sfd);
sfd = -1;
}
if (sfd < 0) {
vkprintf (0, "cannot open server socket at port %d: %m\n", MC->Clusters[i].port);
for (j = 0; j < i; j++) {
if (MC->Clusters[j].other_cluster_no < 0) {
sfd = MC->Clusters[j].server_socket;
close (sfd);
MC->Clusters[j].server_socket = -1;
vkprintf (1, "closed newly-opened listening socket at %s:%d, fd=%d\n", conv_addr (settings_addr.s_addr, 0), MC->Clusters[j].port, sfd);
}
}
return -2;
}
vkprintf (1, "created listening socket at %s:%d, fd=%d\n", conv_addr (settings_addr.s_addr, 0), MC->Clusters[i].port, sfd);
MC->Clusters[i].server_socket = sfd;
}
return 0;
}
int tl_expression_remove_sugar (struct tl_compiler *C, struct tl_expression *E, char *buf) {
vkprintf (4, "tl_expression_remove_sugar (\"%s\")\n", buf);
char *s;
int n = 0;
for (s = buf; *s; s++) {
if (*s == '<') {
*s = ' ';
n++;
} else if (*s == '>') {
*s = ' ';
if (--n < 0) {
return tl_failf (C, "tl_expression_remove_sugar: too many '>', expr: %s", E->text);
}
} else if (*s == ',') {
if (n > 0) {
*s = ' ';
}
}
}
if (n > 0) {
return tl_failf (C, "tl_expression_remove_sugar: too many '<', expr: %s", E->text);
}
cstr_remove_extra_spaces (buf);
vkprintf (4, "after removing sugar: %s\n", buf);
return 0;
}
int rpc_execute_send_data (struct connection *c, struct copyexec_rpc_send_data *P, int len) {
if (len != sizeof (struct copyexec_rpc_send_data)) {
return -__LINE__;
}
host_t *H = get_host_by_connection (c);
if (H == NULL) {
vkprintf (1, "rpc_execute_send_data: get_host_by_connection returns NULL.\n");
return -__LINE__;
}
int r = do_set_result (c, P->transaction_id, P->result, P->binlog_pos);
if (r < 0) {
vkprintf (1, "rpc_execute_send_data: do_set_result (c:%p, transaction_id: %d, result: %u, binlog_pos: 0x%llx) returns %s.\n",
c, P->transaction_id, P->result, P->binlog_pos, copyexec_strerror (r));
return -__LINE__;
}
struct copyexec_rpc_pos *E = rpc_create_query (Q, sizeof (*E), c, COPYEXEC_RPC_TYPE_VALUE_POS);
if (E == NULL) {
return -__LINE__;
}
E->binlog_pos = P->binlog_pos;
return rpc_send_query (Q, c);
}
struct index_entry* index_get (const char *key, int key_len) {
int l = -1;
int r = index_size;
while (r-l > 1) {
int x = (r+l)>>1;
struct index_entry *entry = (struct index_entry *)&index_binary_data[index_offset[x]];
if (mystrcmp (entry->data, entry->key_len, key, key_len) < 0) {
l = x;
} else {
r = x;
}
}
if (verbosity>=4) {
fprintf (stderr, "(l,r) = (%d,%d)\n", l, r);
fprintf (stderr, "index_size = %d\n", index_size);
}
l++;
struct index_entry *entry;
if (l < index_size) {
entry = (struct index_entry *)&index_binary_data[index_offset[l]];
vkprintf (4, "entry->key_len = %d, key_len = %d\n", entry->key_len, key_len);
if (verbosity >= 6) {
int i;
for (i = 0; i < entry->key_len; i++)
fprintf (stderr, "%c", entry->data[i]);
fprintf (stderr, "\n");
}
}
if (l < index_size && !mystrcmp (entry->data, entry->key_len, key, key_len)) {
vkprintf (4, "Item found in index.\n");
return entry;
}
return &empty_index_entry;
}
int load_index (kfs_file_handle_t Index) {
index_type = PMEMCACHED_TYPE_INDEX_RAM;
if (Index == NULL) {
index_size = 0;
jump_log_ts = 0;
jump_log_pos = 0;
jump_log_crc32 = 0;
snapshot_size = 0;
return 0;
}
int fd = Index->fd;
index_header header;
assert (read (fd, &header, sizeof (index_header)) == sizeof (index_header));
if (header.magic != PMEMCACHED_INDEX_MAGIC) {
fprintf (stderr, "index file is not for pmemcached\n");
return -1;
}
jump_log_ts = header.log_timestamp;
jump_log_pos = header.log_pos1;
jump_log_crc32 = header.log_pos1_crc32;
int nrecords = header.nrecords;
index_size = nrecords;
if (verbosity>=2){
fprintf(stderr, "%d records readed\n", nrecords);
}
//assert (read (fd, index_hash, sizeof (long long)*(nrecords+1)) == sizeof (long long)*(nrecords+1));
index_offset = malloc (sizeof (long long) * (nrecords + 1));
assert (index_offset);
assert (read (fd, index_offset, sizeof (long long)*(nrecords+1)) == sizeof (long long)*(nrecords+1));
/*if (nrecords + 1 > MAX_INDEX_ITEMS) {
fprintf(stderr, "Number of entries limit exceeded in index.\n");
return -1;
}*/
/*if (index_offset[nrecords] > MAX_INDEX_BINARY_DATA) {
fprintf(stderr, "Memory limit exceeded in index.\n");
return -1;
}*/
vkprintf (1, "index_offset[%d]=%lld\n", nrecords, index_offset[nrecords]);
index_binary_data = malloc (index_offset[nrecords]);
assert (index_binary_data);
long long x = read (fd, index_binary_data, index_offset[nrecords]);
if (x != index_offset[nrecords]) {
vkprintf (0, "x = %lld\n", x);
assert (x == index_offset[nrecords]);
}
//close (fd);
if (verbosity>=4){
int i;
for(i = 0; i < index_size; i++) {
struct index_entry* entry = index_get_by_idx (i);
fprintf (stderr, "key_len=%d, data_len=%d\t\t", entry->key_len, entry->data_len);
fprintf (stderr, "key/data=%s\n",entry->data);
}
}
snapshot_size = index_offset[nrecords]+16*(nrecords+1)+sizeof(index_header);
pmemcached_register_replay_logevent();
return 0;
}
int transfer_listening_sockets (struct mc_config *MC, struct mc_config *MC_Old) {
int i, j, k;
for (i = 0; i < MC->clusters_num; i++) {
struct mc_cluster *C = &MC->Clusters[i];
j = C->other_cluster_no;
if (j >= 0) {
assert (j < MC_Old->clusters_num);
struct mc_cluster *OC = &MC_Old->Clusters[j];
assert (OC->port == C->port && OC->other_cluster_no == i);
C->server_socket = OC->server_socket;
C->listening_connection = OC->listening_connection;
OC->server_socket = -1;
OC->listening_connection = 0;
C->listening_connection->extra = &C->mc_proxy_inbound;
} else {
assert (init_listening_connection (C->server_socket, &ct_memcache_server, &C->mc_proxy_inbound) >= 0);
C->listening_connection = Connections + C->server_socket;
}
}
for (k = 0; k <= max_connection; k++) {
struct connection *c = Connections + k;
if (c->basic_type != ct_inbound || c->fd != k) {
continue;
}
struct mc_cluster *OC = ((struct memcache_server_functions *) c->extra)->info;
assert (OC && &OC->mc_proxy_inbound == c->extra);
j = OC->cluster_no;
i = OC->other_cluster_no;
assert (OC == &MC_Old->Clusters[j]);
if (i >= 0) {
struct mc_cluster *C = &MC->Clusters[i];
assert (C->cluster_no == i && C->other_cluster_no == j);
vkprintf (2, "transferring inbound connection #%d (port %d) from old cluster %d to new cluster %d\n", k, OC->port, j, i);
c->extra = &C->mc_proxy_inbound;
} else {
vkprintf (2, "closing inbound connection #%d (port %d) belonging to old cluster %d, no new cluster\n", k, OC->port, j);
force_clear_connection (c);
epoll_close (k);
close (k);
}
}
for (i = 0; i < MC_Old->clusters_num; i++) {
struct mc_cluster *OC = &MC_Old->Clusters[i];
if (OC->other_cluster_no == -1) {
assert (OC->server_socket >= 0);
k = OC->server_socket;
vkprintf (1, "closing unneeded listening connection #%d for port %d belonging to old cluster %d (%s)\n", k, OC->port, i, OC->cluster_name);
force_clear_connection (&Connections[k]);
epoll_close (k);
close (k);
OC->server_socket = -1;
OC->listening_connection = 0;
} else {
assert (OC->server_socket == -1 && !OC->listening_connection);
}
}
return 0;
}
static int rpcc_process_nonce_packet (struct connection *c) {
struct rpcc_data *D = RPCC_DATA(c);
static struct rpc_nonce_packet P;
int res;
if (D->packet_num != -2 || D->packet_type != RPC_NONCE) {
return -2;
}
if (D->packet_len != sizeof (struct rpc_nonce_packet)) {
return -3;
}
assert (read_in (&c->In, &P, D->packet_len) == D->packet_len);
vkprintf (2, "Processing nonce packet, crypto schema: %d, key select: %d\n", P.crypto_schema, P.key_select);
switch (P.crypto_schema) {
case RPC_CRYPTO_NONE:
if (P.key_select) {
return -3;
}
if (D->crypto_flags & 1) {
#ifdef AES
if (D->crypto_flags & 2) {
release_all_unprocessed (&c->Out);
}
#endif
D->crypto_flags = 1;
} else {
return -5;
}
break;
#ifdef AES
case RPC_CRYPTO_AES:
if (!P.key_select || P.key_select != get_crypto_key_id ()) {
return -3;
}
if (!(D->crypto_flags & 2)) {
return -5;
}
if (abs (P.crypto_ts - D->nonce_time) > 30) {
return -6; //less'om
}
res = RPCC_FUNC(c)->rpc_start_crypto (c, P.crypto_nonce, P.key_select);
if (res < 0) {
return -6;
}
break;
#endif
default:
return -4;
}
vkprintf (2, "Processed nonce packet, crypto flags = %d\n", D->crypto_flags);
return 0;
}
int rsa_encrypt (const char *const private_key_name, void *input, int ilen, void **output, int *olen) {
vkprintf (3, "rsa_encrypt (private_key_name = %s, ilen = %d)\n", private_key_name, ilen);
int err = 0;
RSA *privKey = NULL;
*output = NULL;
*olen = -1;
FILE *f = fopen (private_key_name, "rb");
if (f == NULL) {
kprintf ("Couldn't open private key file: %s\n", private_key_name);
return -1;
}
privKey = PEM_read_RSAPrivateKey (f, NULL, NULL, NULL);
if (privKey == NULL) {
kprintf ("PEM_read_RSAPrivateKey returns NULL.\n");
err = -2;
goto clean;
}
fclose (f);
f = NULL;
unsigned char key[32], iv[32];
generate_aes_key (key, iv);
const int rsa_size = RSA_size (privKey);
*olen = 4 + rsa_size + 32 + ilen + AES_BLOCK_SIZE;
unsigned char *b = *output = malloc (*olen);
memcpy (b, &rsa_size, 4);
if (!RSA_private_encrypt (32, key, b + 4, privKey, RSA_PKCS1_PADDING)) {
kprintf ("RSA_private_encrypt fail.\n");
err = -3;
goto clean;
}
memcpy (b + 4 + rsa_size, iv, 32);
EVP_CIPHER_CTX e;
EVP_CIPHER_CTX_init (&e);
EVP_EncryptInit_ex (&e, EVP_aes_256_cbc(), NULL, key, iv);
int c_len, f_len;
EVP_EncryptUpdate (&e, b + 4 + rsa_size + 32, &c_len, input, ilen);
EVP_EncryptFinal_ex (&e, b + 4 + rsa_size + 32 + c_len, &f_len);
EVP_CIPHER_CTX_cleanup (&e);
int r = 4 + rsa_size + 32 + c_len + f_len;
vkprintf (3, "c_len = %d, f_len = %d\n", c_len, f_len);
assert (r <= *olen);
*olen = r;
clean:
if (f != NULL) {
fclose (f);
}
if (privKey) {
RSA_free (privKey);
}
return err;
}
int rpc_fun_kitten_php_start_stop (void **IP, void **Data) {
int op = (long)*Data;
if (op == RPC_READY || op == RPC_STOP_READY) {
if (CQ->in_type != tl_type_conn) { return 0; }
struct connection *c = CQ->extra;
tl_fetch_skip (12);
vkprintf (2, "Kitten php %s\n", op == RPC_READY ? "connected" : "disconnected");
int res = kitten_php_ready (op, c);
vkprintf (2, "Kitten_php_ready: res = %d, fetch_error = %s, new_size = %d\n", res, tl.error, kitten_php_current_count ());
return 0;
}
RPC_FUN_NEXT;
}
int kphp_query_forward_conn (struct connection *c, long long new_actor_id, long long new_qid, int advance) {
vkprintf (1, "default_query_forward: CC->id = %lld, CC->timeout = %lf\n", CC->id, CC->timeout);
assert (c);
if (tl_fetch_error ()) {
return -1;
}
CC->forwarded_queries ++;
forwarded_queries ++;
long long qid = CQ->h->qid;
double save_timeout = CQ->h->custom_timeout;
CQ->h->custom_timeout *= 0.9;
tl_store_init (c, new_qid);
struct tl_query_header *h = CQ->h;
assert (h->actor_id == CC->id);
h->qid = new_qid;
h->actor_id = new_actor_id;
tl_store_header (h);
h->qid = qid;
h->actor_id = CC->id;
h->custom_timeout = save_timeout;
tl_copy_through (tl_fetch_unread (), advance);
CC->methods.create_rpc_query (new_qid);
tl_store_end_ext (CQ->h->real_op);
return 0;
}
static int tcp_rpcs_process_handshake_packet (struct connection *c, struct raw_message *msg) {
struct tcp_rpc_data *D = TCP_RPC_DATA(c);
static struct tcp_rpc_handshake_packet P;
if (!PID.ip) {
init_server_PID (c->our_ip, c->our_port);
if (!PID.ip) {
PID.ip = get_my_ipv4 ();
}
}
if (D->packet_num != -1 || D->packet_type != RPC_HANDSHAKE) {
return -2;
}
if (D->packet_len != sizeof (struct tcp_rpc_handshake_packet)) {
tcp_rpcs_send_handshake_error_packet (c, -3);
return -3;
}
assert (rwm_fetch_data (msg, &P, D->packet_len) == D->packet_len);
memcpy (&D->remote_pid, &P.sender_pid, sizeof (struct process_id));
if (!matches_pid (&PID, &P.peer_pid)) {
vkprintf (1, "PID mismatch during handshake: local %08x:%d:%d:%d, remote %08x:%d:%d:%d\n",
PID.ip, PID.port, PID.pid, PID.utime, P.peer_pid.ip, P.peer_pid.port, P.peer_pid.pid, P.peer_pid.utime);
tcp_rpcs_send_handshake_error_packet (c, -4);
return -4;
}
return 0;
}
static void try_change_zone (void) {
if (cur_zone == NULL) { return; }
vkprintf (3, "%s: %.*s\n", __func__, cur_zone->origin_len, cur_zone->origin);
struct lev_dns_change_zone *E = alloc_log_event (LEV_DNS_CHANGE_ZONE + cur_zone->origin_len, sizeof (struct lev_dns_change_zone) + cur_zone->origin_len, 0);
memcpy (E->origin, cur_zone->origin, cur_zone->origin_len);
cur_zone = NULL;
}
int rpcc_start_crypto (struct connection *c, char *nonce, int key_select) {
struct rpcc_data *D = RPCC_DATA(c);
vkprintf (2, "rpcc_start_crypto: key_select = %d\n", key_select);
if (c->crypto) {
return -1;
}
if (c->In.total_bytes || c->Out.total_bytes || !D->nonce_time) {
return -1;
}
if (!key_select || key_select != get_crypto_key_id ()) {
return -1;
}
struct aes_key_data aes_keys;
if (aes_create_keys (&aes_keys, 1, nonce, D->nonce, D->nonce_time, c->remote_ip, c->remote_port, c->remote_ipv6, c->our_ip, c->our_port, c->our_ipv6) < 0) {
return -1;
}
if (aes_crypto_init (c, &aes_keys, sizeof (aes_keys)) < 0) {
return -1;
}
mark_all_unprocessed (&c->In);
return 1;
}
void tl_compiler_add_error (struct tl_compiler *C) {
vkprintf (2, "%s (%p): %.*s\n", __func__, C, C->tmp_error_buff.pos, C->tmp_error_buff.buff);
if (C->errors < TL_MAX_ERRORS) {
C->error_msg[C->errors++] = tl_string_buffer_to_cstr (&C->tmp_error_buff);
tl_string_buffer_clear (&C->tmp_error_buff);
}
}
int rpcc_connected (struct connection *c) {
c->last_query_sent_time = precise_now;
#ifdef AES
if (RPCC_FUNC(c)->rpc_check_perm) {
int res = RPCC_FUNC(c)->rpc_check_perm (c);
if (res < 0) {
return res;
}
if (!(res &= 3)) {
return -1;
}
RPCC_DATA(c)->crypto_flags = res;
} else {
RPCC_DATA(c)->crypto_flags = 3;
}
#endif
vkprintf (2, "RPC connection #%d: [%s]:%d -> [%s]:%d connected, crypto_flags = %d\n", c->fd, show_our_ip (c), c->our_port, show_remote_ip (c), c->remote_port, RPCC_DATA(c)->crypto_flags);
assert (RPCC_FUNC(c)->rpc_init_crypto);
int res = RPCC_FUNC(c)->rpc_init_crypto (c);
if (res > 0) {
assert (RPCC_DATA(c)->crypto_flags & 4);
} else {
return -1;
}
//write_out (&c->Out, "version\r\n", 9);
assert (RPCC_FUNC(c)->flush_packet);
RPCC_FUNC(c)->flush_packet (c);
return 0;
}
int secure_send_on_answer (void **IP, void **Data) {
vkprintf (2, "fun %s\n", __func__);
struct rpc_query *q = *Data;
struct secure_send_extra *E = q->extra;
if (E->state == 1) {
//resend_answer_ack (q, &E->pid);
q->ev.wakeup_time = precise_now + E->timeout;
insert_event_timer (&q->ev);
return 1;
}
secure_send_s0 --;
secure_send_s1 ++;
E->state ++;
free (E->data);
E->data_size = 0;
E->data = 0;
if (!tl_fetch_error ()) {
tl_init_store (CQ->in_type, CQ->remote_pid, q->qid);
//tl_store_init (CQ->in, q->qid);
tl_store_end_ext (RPC_REQ_RESULT_ACK);
sent_answer_ack ++;
}
if (E->binlog) {
struct lev_answer_rx *L = alloc_log_event (LEV_ANSWER_RX, sizeof (*L), 0);
L->qid = q->qid;
if (binlog_mode_on & 2) {
flush_cbinlog (0);
}
}
int r = ((rpc_fun_t)(*IP))(IP + 1, Data);
if (r < 0) { return r; }
q->ev.wakeup_time = precise_now + E->timeout;
insert_event_timer (&q->ev);
return 1;
}
void __showerror(char *format, const IPTR *args)
{
struct IntuitionBase *IntuitionBase;
struct DosLibrary *DOSBase = NULL;
const char *name = FindTask(NULL)->tc_Node.ln_Name;
if
(
!__forceerrorrequester &&
(DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 0)) != NULL &&
Cli() != NULL
)
{
if (name)
{
PutStr(name);
PutStr(": ");
}
if (args)
VPrintf(format, args);
else
PutStr(format);
PutStr("\n");
}
else
if ((IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 0)))
{
struct EasyStruct es =
{
sizeof(struct EasyStruct),
0,
name,
format,
"Exit"
};
EasyRequestArgs(NULL, &es, NULL, args);
CloseLibrary((struct Library *)IntuitionBase);
}
else
{
if (name)
kprintf("%s: ", name);
if (args) {
vkprintf(format, args);
kprintf("\n");
}
else
kprintf("%s\n", format);
}
if (DOSBase != NULL)
CloseLibrary((struct Library *)DOSBase);
}
void suffix_array_init (suffix_array_t *A, unsigned char *y, int n) {
vkprintf (3, "suffix_array_init (%.*s)\n", n, y);
A->y = y;
A->n = n;
A->p = malloc (4 * n);
suffix_array_sort (A);
suffix_array_lcp_init (A);
}
/* basic functions */
int printk(const char *s, ...)
{
va_list ap;
va_start(ap, s);
int cnt = vkprintf(s, ap);
va_end(ap);
return cnt;
}
int kitten_php_forward (void) {
vkprintf (2, "forward: CC = %p\n", CC);
if (tl_fetch_error ()) {
return -1;
}
if (CQ->h->kitten_php_delay > 0) {
return kitten_php_delay (0, 0);
}
struct connection *c = kitten_php_get_connection (1);
if (c) {
vkprintf (2, "Forwarding: connect = %d\n", c->fd);
long long new_qid = get_free_rpc_qid (CQ->h->qid);
return kphp_query_forward_conn (c, CC->new_id, new_qid, 1);
} else {
return -1;
}
}
int kprintf(const char *fmt, ...)
{
int n;
va_list ap;
va_start(ap, fmt);
n = vkprintf(fmt, ap);
va_end(ap);
return n;
}
/* __warn - like panic, but don't */
void __warn(const char *file, int line, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
kprintf("kernel warning at %s:%d:\n ", file, line);
vkprintf(fmt, ap);
kprintf("\n");
va_end(ap);
}
int rpc_execute_ping (struct connection *c) {
host_t *H = get_host_by_connection (c);
if (H == NULL) {
vkprintf (1, "rpc_execute_ping: get_host_by_connection returns NULL.\n");
return -__LINE__;
}
H->last_action_time = now;
return 0;
}
void warn_slowpath(const char *file, int line, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
kprintf("kernel panic in %s:%d:\n ", file, line);
vkprintf(fmt, ap);
kprintf("\n");
va_end(ap);
}
/* *
* cprintf - formats a string and writes it to stdout
*
* The return value is the number of characters which would be
* written to stdout.
* */
int kprintf(const char *fmt, ...)
{
va_list ap;
int cnt;
va_start(ap, fmt);
cnt = vkprintf(fmt, ap);
va_end(ap);
return cnt;
}
int prealloc_tcp_buffers (void) {
assert (!tcp_recv_buffers_num);
int i;
for (i = MAX_TCP_RECV_BUFFERS - 1; i >= 0; i--) {
struct msg_buffer *X = alloc_msg_buffer ((tcp_recv_buffers_num) ? tcp_recv_buffers[i + 1] : 0, TCP_RECV_BUFFER_SIZE);
if (!X) {
vkprintf (0, "**FATAL**: cannot allocate tcp receive buffer\n");
exit (2);
}
vkprintf (3, "allocated %d byte tcp receive buffer #%d at %p\n", X->chunk->buffer_size, i, X);
tcp_recv_buffers[i] = X;
tcp_recv_iovec[i + 1].iov_base = X->data;
tcp_recv_iovec[i + 1].iov_len = X->chunk->buffer_size;
++ tcp_recv_buffers_num;
tcp_recv_buffers_total_size += X->chunk->buffer_size;
}
return tcp_recv_buffers_num;
}
void panic(const char *fmt, ...)
{
intr_disable();
va_list ap;
va_start(ap, fmt);
kprintf("kernel panic in MODULE:\n ");
vkprintf(fmt, ap);
kprintf("\n");
va_end(ap);
}
int secure_send_on_free (void **IP, void **Data) {
vkprintf (2, "fun %s\n", __func__);
struct rpc_query *q = *Data;
struct secure_send_extra *E = q->extra;
assert (E->state == 1);
secure_send_s1 --;
if (E->data) { free (E->data); }
zfree (E, sizeof (*E));
RPC_FUN_NEXT;
}
int tl_success (struct tl_compiler *C, int old_errors) {
vkprintf (5, "tl_success (%p, %d)\n", C, old_errors);
while (C->errors > old_errors) {
C->errors--;
if (C->error_msg[C->errors]) {
cstr_free (&C->error_msg[C->errors]);
}
}
return 0;
}
void dde_kit_debug(const char *fmt, ...)
{
intr_disable();
va_list ap;
va_start(ap, fmt);
kprintf("debug in DDE:\n ");
vkprintf(fmt, ap);
kprintf("\n");
va_end(ap);
}
