int gcov_flush(cp_grant_id_t grantid, int bufsize)
{
/* Initialize global state. */
pos=0;
grant = grantid;
gcov_buff_sz = bufsize;
assert(!gcov_enable);
assert(!gcov_opened);
gcov_enable = 1;
/* Trigger copying.
* This function is not always available, but there is a do-nothing
* version in libc so that executables can be linked even without
* this code ever being activated.
*/
__gcov_flush();
/* Mark the end of the data, stop. */
add_int(GCOVOP_END);
assert(!gcov_opened);
assert(gcov_enable);
gcov_enable = 0;
/* Return number of bytes used in buffer. */
return pos;
}
void AntiSem::add_any(ulen dcount)
{
if( Dev::IsIntContext() )
add_int(dcount);
else
add(dcount);
}
/// @memberof between/3
static Int cont_between(USES_REGS1) {
Term t1 = EXTRA_CBACK_ARG(3, 1);
Term t2 = EXTRA_CBACK_ARG(3, 2);
Yap_unify(ARG3, t1);
if (IsIntegerTerm(t1)) {
Int i1;
Term tn;
if (t1 == t2)
cut_succeed();
i1 = IntegerOfTerm(t1);
tn = add_int(i1, 1 PASS_REGS);
EXTRA_CBACK_ARG(3, 1) = tn;
HB = B->cp_h = HR;
return TRUE;
} else {
Term t[2];
Term tn;
Int cmp;
cmp = Yap_acmp(t1, t2 PASS_REGS);
if (cmp == 0)
cut_succeed();
t[0] = t1;
t[1] = MkIntTerm(1);
tn = Eval(Yap_MkApplTerm(FunctorPlus, 2, t) PASS_REGS);
EXTRA_CBACK_ARG(3, 1) = tn;
HB = B->cp_h = HR;
return TRUE;
}
}
FILE *_gcov_fopen(char *name, char *mode)
{
if(!gcov_enable) return;
assert(!gcov_opened);
/* write information to buffer */
add_int(GCOVOP_OPEN);
add_int(strlen(name)+1);
add_buff(name, strlen(name)+1);
gcov_opened = 1;
/* return dummy FILE *. */
return &gcov_file;
}
QUEUE_INT checkAndAddCriticalTask(TASK* node, QUEUE_INT criticalTasks) {
if (node->earlyDate == node->lateDate) {
criticalTasks = add_int(node->id, criticalTasks);
}
return criticalTasks;
}
int main (void)
{
x = add_int (1, 2);
x = add_short (3, 4);
x = add_ushort (5, 6);
x = add_unsigned (7, 8);
return 0;
}
int _gcov_fclose(FILE *stream)
{
if(!gcov_enable) return;
add_int(GCOVOP_CLOSE);
assert(gcov_opened);
gcov_opened = 0;
return 0;
}
inline int sub_int(int a,int b)
// Calculating a-b; abortion by int overflow.
{
if (b<0 && -b<0)
{
std::cerr << "ERROR in int sub_int(int,int): Overflow!" << std::endl;
exit(1);
}
return add_int(a,-b);
}
size_t _gcov_fwrite(void *ptr, size_t itemsize, size_t nitems, FILE *stream)
{
int size = itemsize * nitems;
if(!gcov_enable) return;
/* only have one file open at a time to ensure writes go
* to the right place.
*/
assert(gcov_opened);
assert(stream == &gcov_file);
/* write information to buffer */
add_int(GCOVOP_WRITE);
add_int(size);
add_buff(ptr, size);
return nitems;
}
void
thread_add(int begin)
{
printf(1, "Starting child thread\n");
int i;
for(i=0; i<amount; i++)
add_int(begin + i);
printf(1, "Finishing child thread\n");
exit();
}
void quassel_set_last_seen_msg(GIOChannel* h, int buffer_id, int msg_id) {
char msg[2048];
int size = 0;
bzero(msg, sizeof(msg));
//A list
size += add_qvariant(msg+size, 9);
//5 elements
size += add_int(msg+size, 6);
//A sync operation
size += add_qvariant(msg+size, 2);
size += add_int(msg+size, 1);
//'BufferSyncer' bytearray
size += add_qvariant(msg+size, 12);
size += add_bytearray(msg+size, "BufferSyncer");
//Empty string
size += add_qvariant(msg+size, 10);
size += add_int(msg+size, 0xffffffff);
size += add_qvariant(msg+size, 12);
size += add_bytearray(msg+size, "requestSetLastSeenMsg");
//BufferId type
size += add_qvariant(msg+size, 127);
size += add_bytearray(msg+size, "BufferId");
size += add_int(msg+size, buffer_id);
//MsgId type
size += add_qvariant(msg+size, 127);
size += add_bytearray(msg+size, "MsgId");
size += add_int(msg+size, msg_id);
uint32_t v = htonl(size);
write_io(h, (char*)&v, 4);
write_io(h, msg, size);
}
int
main (int argc, char* argv[])
{
amount = atoi(argv[1]);
int i = 0;
char* stack;
lock_init(&add);
if ((stack = malloc(4096)) > 0)
thread_create((void*)&thread_add, stack, 4096, &i);
else
printf(1, "Failed to malloc(4096) for new thread stack\n");
int begin = amount * 2;
add_int(begin++);
for(i=1; i<amount; i++)
add_int(begin++);
ll_print(start);
printf(1, "Main thread waiting for child thread finish\n");
wait();
ll_print(start);
exit();
}
void quassel_append_buffer(GIOChannel *h, int buffer) {
char msg[2048];
int size;
size=0;
bzero(msg, sizeof(msg));
//QVariant<QList<QVariant>> of 6 elements
size+=add_qvariant(msg+size, 9);
size+=add_int(msg+size, 6);
//QVariant<Int> = Sync
size+=add_qvariant(msg+size, 2);
size+=add_int(msg+size, 1);
size+=add_qvariant(msg+size, 10);
size+=add_string(msg+size, "BufferViewConfig");
size+=add_qvariant(msg+size, 10);
size+=add_string(msg+size, "0");
size+=add_qvariant(msg+size, 10);
size+=add_string(msg+size, "requestAddBuffer");
size+=add_qvariant(msg+size, 127);
size+=add_bytearray(msg+size, "BufferId");
size+=add_int(msg+size, buffer);
size+=add_qvariant(msg+size, 2);
size+=add_int(msg+size, INT_MAX);
//The message will be of that length
uint32_t v=htonl(size);
write_io(h, (char*)&v, 4);
write_io(h, msg, size);
}
ObjectSettings
BicyclePlatform::get_settings()
{
auto result = GameObject::get_settings();
result.add_float(_("X"), &m_center.x, "x", 0.0f, OPTION_HIDDEN);
result.add_float(_("Y"), &m_center.y, "y", 0.0f, OPTION_HIDDEN);
result.add_int(_("Platforms"), &m_platforms, "platforms", 2);
result.add_float(_("Radius"), &m_radius, "radius", 128);
result.add_float(_("Momentum change rate"), &m_momentum_change_rate, "momentum-change-rate", 0.1f);
result.reorder({"platforms", "x", "y"});
return result;
}
/*
* Add iCalendar recur-rule-parts to a structured element.
*/
void icalrecurrencetype_add_as_xxx(struct icalrecurrencetype *recur, void *obj,
void (*add_int)(void *, const char *, int),
void (*add_str)(void *, const char *,
const char *))
{
char *rrule, *rpart;
tok_t rparts;
/* generate an iCal RRULE string */
rrule = icalrecurrencetype_as_string_r(recur);
/* split string into rparts & values */
tok_initm(&rparts, rrule, "=;", TOK_TRIMLEFT|TOK_TRIMRIGHT);
while ((rpart = tok_next(&rparts))) {
if (!strcmp(rpart, "UNTIL")) {
/* need to translate date format to ISO */
struct icaltimetype until = icaltime_from_string(tok_next(&rparts));
add_str(obj, "until", icaltime_as_iso_string(until));
}
else {
/* assume the rpart has multiple values - split them */
tok_t vlist;
char *val, *p;
tok_init(&vlist, tok_next(&rparts), ",",
TOK_TRIMLEFT|TOK_TRIMRIGHT);
while ((val = tok_next(&vlist))) {
if (add_int) {
/* try converting value to integer */
int n = strtol(val, &p, 10);
if (n && !*p) {
add_int(obj, lcase(rpart), n);
continue;
}
}
add_str(obj, lcase(rpart), val);
}
tok_fini(&vlist);
}
}
tok_fini(&rparts);
free(rrule);
}
void quassel_request_backlog(GIOChannel *h, int buffer, int first, int last, int limit, int additional) {
char msg[2048];
int size;
size=0;
bzero(msg, sizeof(msg));
//QVariant<QList<QVariant>> of 9 elements
size+=add_qvariant(msg+size, 9);
size+=add_int(msg+size, 9);
//QVariant<Int> = Sync
size+=add_qvariant(msg+size, 2);
size+=add_int(msg+size, 1);
size+=add_qvariant(msg+size, 10);
size+=add_string(msg+size, "BacklogManager");
size+=add_qvariant(msg+size, 10);
size+=add_string(msg+size, "");
size+=add_qvariant(msg+size, 10);
size+=add_string(msg+size, "requestBacklog");
size+=add_qvariant(msg+size, 127);
size+=add_bytearray(msg+size, "BufferId");
size+=add_int(msg+size, buffer);
size+=add_qvariant(msg+size, 127);
size+=add_bytearray(msg+size, "MsgId");
size+=add_int(msg+size, first);
size+=add_qvariant(msg+size, 127);
size+=add_bytearray(msg+size, "MsgId");
size+=add_int(msg+size, last);
size+=add_qvariant(msg+size, 2);
size+=add_int(msg+size, limit);
size+=add_qvariant(msg+size, 2);
size+=add_int(msg+size, additional);
//The message will be of that length
uint32_t v=htonl(size);
write_io(h, (char*)&v, 4);
write_io(h, msg, size);
}
int breakpoint_Relocation::pack_data() {
short* p = data();
assert(p == &live_bits(), "initializing live_bits");
*p++ = _bits;
jint target_bits = (jint) internal() ? scaled_offset (_target)
: runtime_address_to_index(_target);
if (settable()) {
// save space for set_target later
add_long(p, target_bits);
} else {
add_int (p, target_bits);
}
for (int i = 0; i < instrlen(); i++) {
add_short(p, (short)0x7777); // placeholder value until bytes can be saved
}
return p - data();
}
static void register_constants(PyObject *module)
{
/* hum, libgto constant are unsigned long, but the biggest is (1UL << 18) so
Int should be OK */
#define add_int(NAME, VALUE) PyModule_AddIntConstant(module, NAME, (VALUE))
#define add_flag(NAME, VALUE) add_int(NAME, (1UL << VALUE))
add_flag("NETLOAD_IF_FLAGS_ALLMULTI", GLIBTOP_IF_FLAGS_ALLMULTI);
add_flag("NETLOAD_IF_FLAGS_ALTPHYS", GLIBTOP_IF_FLAGS_ALTPHYS);
add_flag("NETLOAD_IF_FLAGS_BROADCAST", GLIBTOP_IF_FLAGS_BROADCAST);
add_flag("NETLOAD_IF_FLAGS_DEBUG", GLIBTOP_IF_FLAGS_DEBUG);
add_flag("NETLOAD_IF_FLAGS_LINK0", GLIBTOP_IF_FLAGS_LINK0);
add_flag("NETLOAD_IF_FLAGS_LINK1", GLIBTOP_IF_FLAGS_LINK1);
add_flag("NETLOAD_IF_FLAGS_LINK2", GLIBTOP_IF_FLAGS_LINK2);
add_flag("NETLOAD_IF_FLAGS_LOOPBACK", GLIBTOP_IF_FLAGS_LOOPBACK);
add_flag("NETLOAD_IF_FLAGS_MULTICAST", GLIBTOP_IF_FLAGS_MULTICAST);
add_flag("NETLOAD_IF_FLAGS_NOARP", GLIBTOP_IF_FLAGS_NOARP);
add_flag("NETLOAD_IF_FLAGS_OACTIVE", GLIBTOP_IF_FLAGS_OACTIVE);
add_flag("NETLOAD_IF_FLAGS_POINTOPOINT", GLIBTOP_IF_FLAGS_POINTOPOINT);
add_flag("NETLOAD_IF_FLAGS_PROMISC", GLIBTOP_IF_FLAGS_PROMISC);
add_flag("NETLOAD_IF_FLAGS_RUNNING", GLIBTOP_IF_FLAGS_RUNNING);
add_flag("NETLOAD_IF_FLAGS_SIMPLEX", GLIBTOP_IF_FLAGS_SIMPLEX);
add_flag("NETLOAD_IF_FLAGS_UP", GLIBTOP_IF_FLAGS_UP);
add_int("NETLOAD_SCOPE6_GLOBAL", GLIBTOP_IF_IN6_SCOPE_GLOBAL);
add_int("NETLOAD_SCOPE6_HOST", GLIBTOP_IF_IN6_SCOPE_HOST);
add_int("NETLOAD_SCOPE6_LINK", GLIBTOP_IF_IN6_SCOPE_LINK);
add_int("NETLOAD_SCOPE6_SITE", GLIBTOP_IF_IN6_SCOPE_SITE);
add_int("NETLOAD_SCOPE6_UNKNOWN", GLIBTOP_IF_IN6_SCOPE_UNKNOWN);
add_int("PROCLIST_KERN_PROC_ALL", GLIBTOP_KERN_PROC_ALL);
add_int("PROCLIST_KERN_PROC_PID", GLIBTOP_KERN_PROC_PID);
add_int("PROCLIST_KERN_PROC_PGRP", GLIBTOP_KERN_PROC_PGRP);
add_int("PROCLIST_KERN_PROC_SESSION", GLIBTOP_KERN_PROC_SESSION);
add_int("PROCLIST_KERN_PROC_TTY", GLIBTOP_KERN_PROC_TTY);
add_int("PROCLIST_KERN_PROC_UID", GLIBTOP_KERN_PROC_UID);
add_int("PROCLIST_KERN_PROC_RUID", GLIBTOP_KERN_PROC_RUID);
add_int("PROCLIST_KERN_PROC_MASK", GLIBTOP_KERN_PROC_MASK);
add_int("PROCLIST_EXCLUDE_IDLE", GLIBTOP_EXCLUDE_IDLE);
add_int("PROCLIST_EXCLUDE_SYSTEM", GLIBTOP_EXCLUDE_SYSTEM);
add_int("PROCLIST_EXCLUDE_NOTTY", GLIBTOP_EXCLUDE_NOTTY);
add_int("PPP_STATE_UNKNOWN", GLIBTOP_PPP_STATE_UNKNOWN);
add_int("PPP_STATE_HANGUP", GLIBTOP_PPP_STATE_HANGUP);
add_int("PPP_STATE_ONLINE", GLIBTOP_PPP_STATE_ONLINE);
add_int("PROCESS_RUNNING", GLIBTOP_PROCESS_RUNNING);
add_int("PROCESS_INTERRUPTIBLE", GLIBTOP_PROCESS_INTERRUPTIBLE);
add_int("PROCESS_UNINTERRUPTIBLE", GLIBTOP_PROCESS_UNINTERRUPTIBLE);
add_int("PROCESS_ZOMBIE", GLIBTOP_PROCESS_ZOMBIE);
add_int("PROCESS_STOPPED", GLIBTOP_PROCESS_STOPPED);
add_int("PROCESS_SWAPPING", GLIBTOP_PROCESS_SWAPPING);
add_int("PROCESS_DEAD", GLIBTOP_PROCESS_DEAD);
add_int("MAP_PERM_READ", GLIBTOP_MAP_PERM_READ);
add_int("MAP_PERM_WRITE", GLIBTOP_MAP_PERM_WRITE);
add_int("MAP_PERM_EXECUTE", GLIBTOP_MAP_PERM_EXECUTE);
add_int("MAP_PERM_SHARED", GLIBTOP_MAP_PERM_SHARED);
add_int("MAP_PERM_PRIVATE", GLIBTOP_MAP_PERM_PRIVATE);
add_int("FILE_TYPE_FILE", GLIBTOP_FILE_TYPE_FILE);
add_int("FILE_TYPE_PIPE", GLIBTOP_FILE_TYPE_PIPE);
add_int("FILE_TYPE_INETSOCKET", GLIBTOP_FILE_TYPE_INETSOCKET);
add_int("FILE_TYPE_LOCALSOCKET", GLIBTOP_FILE_TYPE_LOCALSOCKET);
#undef add_flag
#undef add_int
}
void
LDAPinit_constants( PyObject* d )
{
PyObject *zero, *author,*obj;
reverse = PyDict_New();
forward = PyDict_New();
PyDict_SetItemString( d, "_reverse", reverse );
PyDict_SetItemString( d, "_forward", forward );
#define add_int(d, name) \
{ \
PyObject *i = PyInt_FromLong(LDAP_##name); \
PyDict_SetItemString( d, #name, i ); \
Py_DECREF(i); \
}
/* simple constants */
add_int(d,API_VERSION);
add_int(d,VENDOR_VERSION);
add_int(d,PORT);
add_int(d,VERSION1);
add_int(d,VERSION2);
add_int(d,VERSION3);
add_int(d,VERSION_MIN);
add_int(d,VERSION);
add_int(d,VERSION_MAX);
add_int(d,TAG_MESSAGE);
add_int(d,TAG_MSGID);
add_int(d,REQ_BIND);
add_int(d,REQ_UNBIND);
add_int(d,REQ_SEARCH);
add_int(d,REQ_MODIFY);
add_int(d,REQ_ADD);
add_int(d,REQ_DELETE);
add_int(d,REQ_MODRDN);
add_int(d,REQ_COMPARE);
add_int(d,REQ_ABANDON);
add_int(d,TAG_LDAPDN);
add_int(d,TAG_LDAPCRED);
add_int(d,TAG_CONTROLS);
add_int(d,TAG_REFERRAL);
add_int(d,REQ_EXTENDED);
#if LDAP_API_VERSION >= 2004
add_int(d,TAG_NEWSUPERIOR);
add_int(d,TAG_EXOP_REQ_OID);
add_int(d,TAG_EXOP_REQ_VALUE);
add_int(d,TAG_EXOP_RES_OID);
add_int(d,TAG_EXOP_RES_VALUE);
#ifdef HAVE_SASL
add_int(d,TAG_SASL_RES_CREDS);
#endif
#endif
add_int(d,SASL_AUTOMATIC);
add_int(d,SASL_INTERACTIVE);
add_int(d,SASL_QUIET);
/* reversibles */
zero = PyInt_FromLong( 0 );
PyDict_SetItem( reverse, zero, Py_None );
Py_DECREF( zero );
add_int(d,RES_BIND);
add_int(d,RES_SEARCH_ENTRY);
add_int(d,RES_SEARCH_RESULT);
add_int(d,RES_MODIFY);
add_int(d,RES_ADD);
add_int(d,RES_DELETE);
add_int(d,RES_MODRDN);
add_int(d,RES_COMPARE);
add_int(d,RES_ANY);
add_int(d,RES_SEARCH_REFERENCE);
add_int(d,RES_EXTENDED);
add_int(d,RES_UNSOLICITED);
/* non-reversibles */
add_int(d,AUTH_NONE);
add_int(d,AUTH_SIMPLE);
add_int(d,SCOPE_BASE);
add_int(d,SCOPE_ONELEVEL);
add_int(d,SCOPE_SUBTREE);
add_int(d,MOD_ADD);
add_int(d,MOD_DELETE);
add_int(d,MOD_REPLACE);
add_int(d,MOD_INCREMENT);
add_int(d,MOD_BVALUES);
add_int(d,MSG_ONE);
add_int(d,MSG_ALL);
add_int(d,MSG_RECEIVED);
/* (errors.c contains the error constants) */
add_int(d,DEREF_NEVER);
add_int(d,DEREF_SEARCHING);
add_int(d,DEREF_FINDING);
add_int(d,DEREF_ALWAYS);
add_int(d,NO_LIMIT);
add_int(d,OPT_API_INFO);
add_int(d,OPT_DEREF);
add_int(d,OPT_SIZELIMIT);
add_int(d,OPT_TIMELIMIT);
#ifdef LDAP_OPT_REFERRALS
add_int(d,OPT_REFERRALS);
#endif
add_int(d,OPT_ERROR_NUMBER);
add_int(d,OPT_RESTART);
add_int(d,OPT_PROTOCOL_VERSION);
add_int(d,OPT_SERVER_CONTROLS);
add_int(d,OPT_CLIENT_CONTROLS);
add_int(d,OPT_API_FEATURE_INFO);
add_int(d,OPT_HOST_NAME);
/* For backward-compability with OpenLDAP 2.3 libs this is defined in ldap/__init__.py */
/* add_int(d,OPT_DIAGNOSTIC_MESSAGE); */
add_int(d,OPT_ERROR_STRING);
add_int(d,OPT_MATCHED_DN);
add_int(d,OPT_DEBUG_LEVEL);
add_int(d,OPT_TIMEOUT);
add_int(d,OPT_REFHOPLIMIT);
add_int(d,OPT_NETWORK_TIMEOUT);
add_int(d,OPT_URI);
#ifdef HAVE_TLS
add_int(d,OPT_X_TLS);
add_int(d,OPT_X_TLS_CTX);
add_int(d,OPT_X_TLS_CACERTFILE);
add_int(d,OPT_X_TLS_CACERTDIR);
add_int(d,OPT_X_TLS_CERTFILE);
add_int(d,OPT_X_TLS_KEYFILE);
add_int(d,OPT_X_TLS_REQUIRE_CERT);
add_int(d,OPT_X_TLS_CIPHER_SUITE);
add_int(d,OPT_X_TLS_RANDOM_FILE);
add_int(d,OPT_X_TLS_NEVER);
add_int(d,OPT_X_TLS_HARD);
add_int(d,OPT_X_TLS_DEMAND);
add_int(d,OPT_X_TLS_ALLOW);
add_int(d,OPT_X_TLS_TRY);
/* only available if OpenSSL supports it => might cause backward compability problems */
add_int(d,OPT_X_TLS_CRLCHECK);
add_int(d,OPT_X_TLS_CRL_NONE);
add_int(d,OPT_X_TLS_CRL_PEER);
add_int(d,OPT_X_TLS_CRL_ALL);
#endif
add_int(d,OPT_X_SASL_MECH);
add_int(d,OPT_X_SASL_REALM);
add_int(d,OPT_X_SASL_AUTHCID);
add_int(d,OPT_X_SASL_AUTHZID);
add_int(d,OPT_X_SASL_SSF);
add_int(d,OPT_X_SASL_SSF_EXTERNAL);
add_int(d,OPT_X_SASL_SECPROPS);
add_int(d,OPT_X_SASL_SSF_MIN);
add_int(d,OPT_X_SASL_SSF_MAX);
add_int(d,DN_FORMAT_LDAP);
add_int(d,DN_FORMAT_LDAPV3);
add_int(d,DN_FORMAT_LDAPV2);
add_int(d,DN_FORMAT_DCE);
add_int(d,DN_FORMAT_UFN);
add_int(d,DN_FORMAT_AD_CANONICAL);
/* add_int(d,DN_FORMAT_LBER); */ /* "for testing only" */
add_int(d,DN_FORMAT_MASK);
add_int(d,DN_PRETTY);
add_int(d,DN_SKIP);
add_int(d,DN_P_NOLEADTRAILSPACES);
add_int(d,DN_P_NOSPACEAFTERRDN);
add_int(d,DN_PEDANTIC);
add_int(d,AVA_NULL);
add_int(d,AVA_STRING);
add_int(d,AVA_BINARY);
add_int(d,AVA_NONPRINTABLE);
/*add_int(d,OPT_ON);*/
obj = PyInt_FromLong(1);
PyDict_SetItemString( d, "LDAP_OPT_ON", obj );
Py_DECREF(obj);
/*add_int(d,OPT_OFF);*/
obj = PyInt_FromLong(0);
PyDict_SetItemString( d, "LDAP_OPT_OFF", obj );
Py_DECREF(obj);
add_int(d,OPT_SUCCESS);
/* XXX - these belong in errors.c */
add_int(d,URL_ERR_BADSCOPE);
add_int(d,URL_ERR_MEM);
/* author */
author = PyBytes_FromString("*****@*****.**");
PyDict_SetItemString(d, "__author__", author);
Py_DECREF(author);
/* add_int(d,LIBLDAP_R); */
#ifdef HAVE_LIBLDAP_R
obj = PyInt_FromLong(1);
#else
obj = PyInt_FromLong(0);
#endif
PyDict_SetItemString( d, "LIBLDAP_R", obj );
Py_DECREF(obj);
/* add_int(d,SASL); */
#ifdef HAVE_SASL
obj = PyInt_FromLong(1);
#else
obj = PyInt_FromLong(0);
#endif
PyDict_SetItemString( d, "SASL_AVAIL", obj );
Py_DECREF(obj);
/* add_int(d,TLS); */
#ifdef HAVE_TLS
obj = PyInt_FromLong(1);
#else
obj = PyInt_FromLong(0);
#endif
PyDict_SetItemString( d, "TLS_AVAIL", obj );
Py_DECREF(obj);
obj = PyBytes_FromString(LDAP_CONTROL_PAGE_OID);
PyDict_SetItemString( d, "LDAP_CONTROL_PAGE_OID", obj );
Py_DECREF(obj);
obj = PyBytes_FromString(LDAP_CONTROL_VALUESRETURNFILTER);
PyDict_SetItemString( d, "LDAP_CONTROL_VALUESRETURNFILTER", obj );
Py_DECREF(obj);
}
int diag_describe(diag_output_t *o, diag_context_t *c)
{
char buf[256];
char *outch;
char *lastoutch = buf + sizeof buf - 1;
const char *ch;
int i;
DWORD bytes_written;
outch = buf;
outch = add_string(outch, lastoutch, "Process id: ", NULL);
outch = add_int(outch, lastoutch, (long long)_getpid(), 10);
if (o->output_mode == DIAG_WRITE_FD) {
outch = add_string(outch, lastoutch, "\r\n", NULL);
WriteFile(o->outfile, buf, strlen(buf), &bytes_written, NULL);
}
else {
o->output_fn(o->user_data, buf);
}
if (c->exception_record) {
outch = buf;
outch = add_string(outch, lastoutch, "Exception code: ", NULL);
ch = NULL;
for (i = 0; i < sizeof(ec_strs) / sizeof(ec_strs[0]); i++) {
if (ec_strs[i].symbol == c->exception_record->ExceptionCode) {
ch = ec_strs[i].str;
break;
}
}
if (ch == NULL) {
outch = add_int(outch, lastoutch, (long long)c->exception_record->ExceptionCode, 10);
}
else {
outch = add_string(outch, lastoutch, ch, NULL);
}
if (o->output_mode == DIAG_WRITE_FD) {
outch = add_string(outch, lastoutch, "\r\n", NULL);
WriteFile(o->outfile, buf, strlen(buf), &bytes_written, NULL);
}
else {
o->output_fn(o->user_data, buf);
}
outch = buf;
outch = add_string(outch, lastoutch, "Exception address: ", NULL);
outch = add_int(outch, lastoutch, (long long)c->exception_record->ExceptionAddress, 16);
if (o->output_mode == DIAG_WRITE_FD) {
outch = add_string(outch, lastoutch, "\r\n", NULL);
WriteFile(o->outfile, buf, strlen(buf), &bytes_written, NULL);
}
else {
o->output_fn(o->user_data, buf);
}
}
return 0;
}
int diag_backtrace(diag_output_t *o, diag_backtrace_param_t *p, diag_context_t *c)
{
char frame[128];
char addr_buf[20];
char offset_buf[20];
char name_buf[80];
char *name;
const char *module_path, *module;
int count, cur, rc;
unw_context_t ctx;
unw_cursor_t csr;
unw_word_t ip, offp;
#if DIAG_PLATFORM_LINUX || DIAG_PLATFORM_FREEBSD || DIAG_PLATFORM_MACOSX
Dl_info info;
#endif
if (p->backtrace_count && p->backtrace_count < DIAG_BT_LIMIT) {
count = p->backtrace_count;
}
else {
count = DIAG_BT_LIMIT;
}
rc = unw_getcontext(&ctx);
if (!rc) {
rc = unw_init_local(&csr, &ctx);
}
if (rc) {
return DIAG_ERR_INIT;
}
cur = 0;
while ((rc = unw_step(&csr)) > 0) {
cur++;
if (cur > count) {
break;
}
unw_get_reg(&csr, UNW_REG_IP, &ip);
if (!ip) {
break;
}
add_int(addr_buf, addr_buf + sizeof addr_buf - 1, ip, 16);
rc = unw_get_proc_name(&csr, name_buf, sizeof name_buf, &offp);
if (rc && rc != UNW_ENOMEM) {
name = NULL;
}
else {
name = name_buf;
}
module = module_path = NULL;
#if DIAG_PLATFORM_LINUX || DIAG_PLATFORM_FREEBSD || DIAG_PLATFORM_MACOSX
if (p->backtrace_fields
& (DIAG_BTFIELDS_MODULE_PATH | DIAG_BTFIELDS_MODULE_NAME)) {
if ((rc = dladdr((void *)ip, &info)) != 0) {
module_path = info.dli_fname;
module = strrchr(module_path, '/');
if (module) {
module += 1;
}
}
}
#endif
add_int(offset_buf, offset_buf + sizeof offset_buf - 1,
offp, 16);
output_frame(frame, frame + sizeof frame - 1,
p->backtrace_fields,
module_path, module, name, offset_buf, addr_buf);
if (o->output_mode == DIAG_CALL_FN) {
o->output_fn(o->user_data, frame);
}
else {
write(o->outfile, frame, strlen(frame));
write(o->outfile, "\n", 1);
}
}
return 0;
}
int diag_backtrace(diag_output_t *o, diag_backtrace_param_t *p, diag_context_t *c)
{
int cur = 0, count;
STACKFRAME64 stackframe;
CONTEXT context;
HANDLE process = GetCurrentProcess();
HANDLE thread = GetCurrentThread();
DWORD bytes_written;
if (c) {
context = *c->context;
}
else {
RtlCaptureContext(&context);
}
if (p->backtrace_count && p->backtrace_count < DIAG_BT_LIMIT) {
count = p->backtrace_count;
}
else {
count = DIAG_BT_LIMIT;
}
memset(&stackframe, 0, sizeof stackframe);
stackframe.AddrPC.Mode =
stackframe.AddrFrame.Mode =
stackframe.AddrStack.Mode = AddrModeFlat;
#ifdef DIAG_BITS_64
stackframe.AddrPC.Offset = context.Rip;
stackframe.AddrFrame.Offset = context.Rbp;
stackframe.AddrStack.Offset = context.Rsp;
#else
stackframe.AddrPC.Offset = context.Eip;
stackframe.AddrFrame.Offset = context.Ebp;
stackframe.AddrStack.Offset = context.Esp;
#endif
if (!p->symbols_initialized) {
SymInitialize(process, NULL, TRUE);
}
while (StackWalk64(
#ifdef DIAG_BITS_64
IMAGE_FILE_MACHINE_AMD64,
#else
IMAGE_FILE_MACHINE_I386,
#endif
process, thread,
&stackframe,
&context,
NULL, /* ReadMemoryRoutine */
SymFunctionTableAccess64, /* FunctionTableAccessRoutine */
SymGetModuleBase64, /* GetModuleBaseRoutine */
NULL) /* TranslateAddress */
== TRUE) {
char symbol_buffer[128] = {0};
IMAGEHLP_SYMBOL64 *symbol = (IMAGEHLP_SYMBOL64 *)&symbol_buffer;
DWORD64 ignored;
const char *function;
const char *offset;
char address_buf[20], offset_buf[20];
char buf[128];
char *outch = buf;
char *lastoutch = buf + sizeof buf - 1;
if (cur + 1 > count) { /* avoid loop on corrupted chain, respect caller's wishes */
break;
}
symbol->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
symbol->MaxNameLength = sizeof(symbol_buffer) - sizeof(IMAGEHLP_SYMBOL64);
ignored = 0;
if (SymGetSymFromAddr64(process, stackframe.AddrPC.Offset, &ignored, symbol) != TRUE) {
function = NULL;
offset = NULL;
}
else {
function = symbol->Name;
add_int(offset_buf, offset_buf + sizeof offset_buf - 1,
stackframe.AddrPC.Offset - symbol->Address, 16);
offset = offset_buf;
}
add_int(address_buf, address_buf + sizeof address_buf - 1,
stackframe.AddrPC.Offset, 16);
if (function && !strcmp(function, "diag_backtrace")) {
/* filter outselves out */
continue;
}
cur++; /* gonna keep this frame, so count it */
output_frame(outch, lastoutch, p->backtrace_fields,
NULL, /* no module path */
NULL, /* no module */
function,
offset,
address_buf);
if (o->output_mode == DIAG_CALL_FN) {
o->output_fn(o->user_data, buf);
}
else {
WriteFile(o->outfile, buf, strlen(buf), &bytes_written, NULL);
WriteFile(o->outfile, "\r\n", 2, &bytes_written, NULL);
}
}
return 0;
}
