static void write_pointer( FILE *f, void *p, ptr_type_t type ) {
const save_ptr_t *ptr;
int i;
if( !p ) {
write_int( f, -1 );
return;
}
for( i = 0, ptr = save_ptrs; i < num_save_ptrs; i++, ptr++ ) {
if( ptr->type == type && ptr->ptr == p ) {
write_int( f, i );
return;
}
}
gi.error( "%s: unknown pointer: %p", __func__, p );
}
static void write_index( FILE *f, void *p, size_t size, void *start, int max_index ) {
size_t diff;
if( !p ) {
write_int( f, -1 );
return;
}
if( p < start || ( byte * )p > ( byte * )start + max_index * size ) {
gi.error( "%s: pointer out of range: %p", __func__, p );
}
diff = p - start;
if( diff % size ) {
gi.error( "%s: misaligned pointer: %p", __func__, p );
}
write_int( f, ( int )( diff / size ) );
}
inline void write_int( LL n )
{
//recursive function to load the number to output buffer array(buf2)
if( n >= 10 )
{
write_int( n / 10 ) ;
}
write_char( '0' + n % 10 ) ;
}
static void write_string(int fd, char* val) {
int len = strlen(val);
write_int(fd, len);
int written = write(fd, val, len);
if (written != len) {
PLOGE("unable to write string");
exit(-1);
}
}
void UniformSymbolCoder<RAC>::write_int(int min, int max, int val) {
assert(max >= min);
if (min != 0) {
max -= min;
val -= min;
}
if (max == 0) return;
// split in [0..med] [med+1..max]
int med = max/2;
if (val > med) {
rac.write_bit(true);
write_int(med+1, max, val);
} else {
rac.write_bit(false);
write_int(0, med, val);
}
return;
}
inline void write_Int(int n)
{
if(n<0)
{
write_char('-');
write_flush();
n *= (-1);
}
write_int(n);
}
generator_callback *remote_completion(const char *line, int start)
{
if (write(server_completion_fd, "c", 1) != 1 ||
!write_int(server_completion_fd, start) ||
!write_string(server_completion_fd, line)) {
return NULL;
}
return remote_generator;
}
/* stringlist: <# listitems>
<pos of listend (bytes)>
<string:(size)(aligned string)>
*/
static int bc_stringlist_emit(int fd, int *codep, bytecode_info_t *bc)
{
int len = bc->data[(*codep)++].len;
int i;
int ret;
int wrote = 2*sizeof(int);
int begin,end;
/* Write out number of items in the list */
if (write_int(fd, len)== -1) return -1 ;
/* skip one spot end of list position*/
begin=lseek(fd,0,SEEK_CUR);
lseek(fd,sizeof(int),SEEK_CUR);
/* Loop through all the items of the list, writing out length and string
* in sequence */
for(i=0; i < len; i++)
{
int datalen = bc->data[(*codep)++].len;
if(write_int(fd, datalen) == -1) return -1;
wrote += sizeof(int);
if(write(fd, bc->data[(*codep)++].str, datalen) == -1) return -1;
wrote += datalen;
ret = align_string(fd,datalen);
if(ret == -1) return -1;
wrote+=ret;
}
end=lseek(fd,0,SEEK_CUR);
if (end < 0) return -1;
/* go back and write end of list position */
lseek(fd,begin,SEEK_SET);
if(write_int(fd, end) == -1) return -1;
/* return to the end */
lseek(fd,end,SEEK_SET);
return wrote;
}
static void
write_string (MonoCompile *cfg, const char *str)
{
size_t len = strnlen (str, 0x2000);
write_int (cfg, (int) len);
gunichar2 *u = u8to16 (str);
for (int i = 0; i < len; i++)
write_short (cfg, u[i]);
}
void KfmServIpc::dirEntry(const char* _name, const char* _access, const char* _owner, const char* _group, const char* _date, int _size)
{
int len = 0;
len += len_string( _name );
len += len_string( _access );
len += len_string( _owner );
len += len_string( _group );
len += len_string( _date );
len += len_int( _size );
len += len_string("dirEntry");
write_int( data_sock->socket(), len );
write_string( data_sock->socket(), "dirEntry" );
write_string( data_sock->socket(), _name );
write_string( data_sock->socket(), _access );
write_string( data_sock->socket(), _owner );
write_string( data_sock->socket(), _group );
write_string( data_sock->socket(), _date );
write_int( data_sock->socket(), _size );
}
HOT_INLINE
static void write_endpList(
int size,
hot_endpt_t *ep
) {
int i;
write_int(size);
for (i = 0; i < size; i++)
write_endpID(&ep[i]);
}
static
log_realloc (unsigned oldlen, unsigned newlen, unsigned bsize, char *addr)
{
write_string ("realloc of ");
write_int (oldlen);
write_string ("at ");
write_addr (addr);
write_string ("\n");
write_stack("x");
write_string ("realloc-to of ");
write_int (newlen);
write_string ("gets ");
write_int (bsize);
write_string ("at ");
write_addr (addr);
write_string ("\n");
write_stack("x");
}
int main(void)
{
char mac_param[128];
write_int("/sys/devices/platform/msm_sdcc.3/polling", 1);
getmac(mac_param);
LOGI("Loading Libra.ko");
if ((insmod(DRIVER_MODULE_PATH, mac_param)) < 0){
rmmod("librasdioif");
} else {
usleep(WIFI_DRIVER_LOADER_DELAY);
property_set("wlan.driver.status", "ok");
}
write_int("/sys/devices/platform/msm_sdcc.3/polling", 0);
return 0;
}
void write_int(int min, int max, int val) {
assert(max >= min);
if (min != 0) {
max -= min;
val -= min;
}
if (max == 0) return;
// split in [0..med] [med+1..max]
int med = max/2;
if (val > med) {
rac.write(med+1, max+1, true);
write_int(med+1, max, val);
} else {
rac.write(med+1, max+1, false);
write_int(0, med, val);
}
return;
}
static
print_free_list (unsigned heap)
{
int i;
struct freelist * top;
struct freelist * ptr;
write_string ("free list for heap ");
write_int(heap);
write_string(":\n");
for (i=0; i<BUCKETS; i++) {
top = &heaps[heap][i];
write_int (sizes[i]);
write_string (": ");
for (ptr = top->next ; ptr != top; ptr=ptr->next)
write_int (ptr->size);
write_string ("\n");
}
}
static bool switch_lcd(bool on)
{
const char *NODE_PATH = "/sys/class/leds/lcd-backlight/brightness";
s32 ret = -1;
if(on)
ret = write_int(NODE_PATH, 102);
else
ret = write_int(NODE_PATH, 0);
if(ret < 0)
{
DEBUG("[hotknot factory]Switch lcd fail :%s.", strerror(errno));
return false;
}
DEBUG("[hotknot factory]Switch lcd success.");
return true;
}
/**
* This function allows you to add an encoded video frame to the AVI file.
*
* @param gwavi Main gwavi structure initialized with gwavi_open()-
* @param buffer Video buffer size.
* @param len Video buffer length.
*
* @return 0 on success, -1 on error.
*/
int
gwavi_add_frame(struct gwavi_t *gwavi, unsigned char *buffer, size_t len)
{
size_t maxi_pad; /* if your frame is raggin, give it some paddin' */
size_t t;
if (!gwavi || !buffer) {
(void)fputs("gwavi and/or buffer argument cannot be NULL",
stderr);
return -1;
}
if (len < 256)
(void)fprintf(stderr, "WARNING: specified buffer len seems "
"rather small: %d. Are you sure about this?\n",
(int)len);
gwavi->offset_count++;
gwavi->stream_header_v.data_length++;
maxi_pad = len % 4;
if (maxi_pad > 0)
maxi_pad = 4 - maxi_pad;
if (gwavi->offset_count >= gwavi->offsets_len) {
gwavi->offsets_len += 1024;
gwavi->offsets = (unsigned int *)realloc(gwavi->offsets,
(size_t)gwavi->offsets_len *
sizeof(unsigned int));
}
gwavi->offsets[gwavi->offsets_ptr++] = (unsigned int)(len + maxi_pad);
if (write_chars_bin(gwavi->out, "00dc", 4) == -1) {
(void)fprintf(stderr, "gwavi_add_frame: write_chars_bin() "
"failed\n");
return -1;
}
if (write_int(gwavi->out, (unsigned int)(len + maxi_pad)) == -1) {
(void)fprintf(stderr, "gwavi_add_frame: write_int() failed\n");
return -1;
}
if ((t = fwrite(buffer, 1, len, gwavi->out)) != len) {
(void)fprintf(stderr, "gwavi_add_frame: fwrite() failed\n");
return -1;
}
for (t = 0; t < maxi_pad; t++)
if (fputc(0, gwavi->out) == EOF) {
(void)fprintf(stderr, "gwavi_add_frame: fputc() failed\n");
return -1;
}
return 0;
}
static FcBool
cache_print_set (FcFontSet *set, FcStrSet *dirs, const FcChar8 *base_name, FcBool verbose)
{
FcChar8 *dir;
const FcChar8 *base;
int n;
int ndir = 0;
FcStrList *list;
list = FcStrListCreate (dirs);
if (!list)
goto bail2;
while ((dir = FcStrListNext (list)))
{
base = file_base_name (base_name, dir);
if (!write_string (stdout, base))
goto bail3;
if (PUTC (' ', stdout) == EOF)
goto bail3;
if (!write_int (stdout, 0))
goto bail3;
if (PUTC (' ', stdout) == EOF)
goto bail3;
if (!write_string (stdout, FC_FONT_FILE_DIR))
goto bail3;
if (PUTC ('\n', stdout) == EOF)
goto bail3;
ndir++;
}
for (n = 0; n < set->nfont; n++)
{
FcPattern *font = set->fonts[n];
FcChar8 *s;
s = FcPatternFormat (font, (const FcChar8 *) "%{=fccat}\n");
if (s)
{
printf ("%s", s);
FcStrFree (s);
}
}
if (verbose && !set->nfont && !ndir)
printf ("<empty>\n");
FcStrListDone (list);
return FcTrue;
bail3:
FcStrListDone (list);
bail2:
return FcFalse;
}
/* Join a group. The group context is returned in *contextp.
*/
hot_err_t hot_ens_Join(
hot_ens_JoinOps_t *jops,
hot_context_t *contextp /*OUT*/
) {
hot_err_t err = HOT_OK ;
hot_context_t s ;
/* Initialize global state if not done so already.
*/
if (!g.initialized) {
err = hot_ens_Init(jops->outboard, jops->argv);
if (err != HOT_OK)
return err;
}
begin_write(); {
begin_critical(); {
/* Allocate a new group context
* Initialize the group record.
*/
s = alloc_context();
s->joining = 1 ;
s->leaving = 0 ;
s->conf = jops->conf;
s->env = jops->env;
s->view = NULL ;
*contextp = s ;
} end_critical();
/* Write the downcall.
*/
write_hdr(s,DN_JOIN);
write_int(jops->heartbeat_rate);
write_string(jops->transports);
write_string(jops->protocol);
write_string(jops->group_name);
write_string(jops->properties);
write_bool(jops->use_properties);
write_bool(jops->groupd);
write_string(jops->params);
write_bool(jops->client);
write_bool(jops->debug);
if (jops->endpt.name[0] != 0x0) {
hot_sys_Warning("HOT_OUTBOARD does not support 'endpt' in join ops") ;
jops->endpt.name[0] = 0x0;
}
write_string(jops->princ);
write_string(jops->key);
write_bool(jops->secure);
} end_write();
return HOT_OK;
}
void KfmIpc::move(const char* _src, const char* _dest)
{
int len = 0;
len += len_string( _src );
len += len_string( _dest );
len += len_string("move");
write_int( sock->socket(), len );
write_string( sock->socket(), "move" );
write_string( sock->socket(), _src );
write_string( sock->socket(), _dest );
}
void KfmIpc::exec(const char* _url, const char* _binding)
{
int len = 0;
len += len_string( _url );
len += len_string( _binding );
len += len_string("exec");
write_int( sock->socket(), len );
write_string( sock->socket(), "exec" );
write_string( sock->socket(), _url );
write_string( sock->socket(), _binding );
}
void print_stats(int i){
struct stats st;
get_stats(getpid(), &st);
char b;
write(1, "\nStats for the process ", 23);
write_int(i);
write(1, "\nUser Ticks: ", 13);
write_int(st.user_ticks);
write(1, "\nSystem Ticks: ", 15);
write_int(st.system_ticks);
write(1, "\nBlocked Ticks: ", 16);
write_int(st.blocked_ticks);
write(1, "\nReady Ticks: ", 14);
write_int(st.ready_ticks);
}
void KfmIpc::copyClient(const char* _src, const char* _dest)
{
int len = 0;
len += len_string( _src );
len += len_string( _dest );
len += len_string("copyClient");
write_int( sock->socket(), len );
write_string( sock->socket(), "copyClient" );
write_string( sock->socket(), _src );
write_string( sock->socket(), _dest );
}
void Ctransaction::send_announce(data_ref r)
{
if (read_int(8, &r[uti_connection_id], r.end()) != connection_id())
return;
if (!m_server.config().m_anonymous_announce)
{
send_error(r, "access denied");
return;
}
Ctracker_input ti;
ti.m_downloaded = read_int(8, &r[utia_downloaded], r.end());
ti.m_event = static_cast<Ctracker_input::t_event>(read_int(4, &r[utia_event], r.end()));
ti.m_info_hash.assign(reinterpret_cast<const char*>(&r[utia_info_hash]), 20);
ti.m_ipa = read_int(4, &r[utia_ipa], r.end()) && is_private_ipa(m_a.sin_addr.s_addr)
? htonl(read_int(4, &r[utia_ipa], r.end()))
: m_a.sin_addr.s_addr;
ti.m_left = read_int(8, &r[utia_left], r.end());
ti.m_num_want = read_int(4, &r[utia_num_want], r.end());
ti.m_peer_id.assign(reinterpret_cast<const char*>(&r[utia_peer_id]), 20);
ti.m_port = htons(read_int(2, &r[utia_port], r.end()));
ti.m_uploaded = read_int(8, &r[utia_uploaded], r.end());
std::string error = m_server.insert_peer(ti, true, NULL);
if (!error.empty())
{
send_error(r, error);
return;
}
const Cserver::t_torrent* torrent = m_server.torrent(ti.m_info_hash);
if (!torrent)
return;
const int cb_d = 2 << 10;
char d[cb_d];
write_int(4, d + uto_action, uta_announce);
write_int(4, d + uto_transaction_id, read_int(4, &r[uti_transaction_id], r.end()));
write_int(4, d + utoa_interval, m_server.config().m_announce_interval);
write_int(4, d + utoa_leechers, torrent->leechers);
write_int(4, d + utoa_seeders, torrent->seeders);
std::string peers = torrent->select_peers(ti);
memcpy(d + utoa_size, peers.data(), peers.size());
send(data_ref(d, d + utoa_size + peers.size()));
}
/* Privileged side. */
static void
setgid_io_close_priv (int outfd, int infd)
{
int fd;
int result;
fd = read_int (infd);
result = close (fd);
write_int (outfd, result);
}
int main(){
int i;
int k;
int *l;
k = 10;
l = &k;
i = outprint(l);
write_int(k);
write_string("\n");
}
static void write_field(FILE *f, const save_field_t *field, void *base)
{
void *p = (byte *)base + field->ofs;
int i;
switch (field->type) {
case F_BYTE:
write_data(p, field->size, f);
break;
case F_SHORT:
for (i = 0; i < field->size; i++) {
write_short(f, ((short *)p)[i]);
}
break;
case F_INT:
for (i = 0; i < field->size; i++) {
write_int(f, ((int *)p)[i]);
}
break;
case F_FLOAT:
for (i = 0; i < field->size; i++) {
write_float(f, ((float *)p)[i]);
}
break;
case F_VECTOR:
write_vector(f, (vec_t *)p);
break;
case F_ZSTRING:
write_string(f, (char *)p);
break;
case F_LSTRING:
write_string(f, *(char **)p);
break;
case F_EDICT:
write_index(f, *(void **)p, sizeof(edict_t), g_edicts, MAX_EDICTS - 1);
break;
case F_CLIENT:
write_index(f, *(void **)p, sizeof(gclient_t), game.clients, game.maxclients - 1);
break;
case F_ITEM:
write_index(f, *(void **)p, sizeof(gitem_t), itemlist, game.num_items - 1);
break;
case F_POINTER:
write_pointer(f, *(void **)p, field->size);
break;
default:
gi.error("%s: unknown field type", __func__);
}
}
/**
* This function allows you to add the audio track to your AVI file.
*
* @param gwavi Main gwavi structure initialized with gwavi_open()-
* @param buffer Audio buffer size.
* @param len Audio buffer length.
*
* @return 0 on success, -1 on error.
*/
int
gwavi_add_audio(struct gwavi_t *gwavi, unsigned char *buffer, size_t len)
{
size_t maxi_pad; /* in case audio bleeds over the 4 byte boundary */
size_t t;
if (!gwavi || !buffer) {
(void)fputs("gwavi and/or buffer argument cannot be NULL",
stderr);
return -1;
}
gwavi->offset_count++;
maxi_pad = len % 4;
if (maxi_pad > 0)
maxi_pad = 4 - maxi_pad;
if (gwavi->offset_count >= gwavi->offsets_len) {
gwavi->offsets_len += 1024;
gwavi->offsets = (unsigned int *)realloc(gwavi->offsets,
(size_t)gwavi->offsets_len *
sizeof(unsigned int));
}
gwavi->offsets[gwavi->offsets_ptr++] =
(unsigned int)((len + maxi_pad) | 0x80000000);
if (write_chars_bin(gwavi->out,"01wb",4) == -1) {
(void)fprintf(stderr, "gwavi_add_audio: write_chars_bin() "
"failed\n");
return -1;
}
if (write_int(gwavi->out,(unsigned int)(len + maxi_pad)) == -1) {
(void)fprintf(stderr, "gwavi_add_audio: write_int() failed\n");
return -1;
}
if ((t = fwrite(buffer, 1, len, gwavi->out)) != len ) {
(void)fprintf(stderr, "gwavi_add_audio: fwrite() failed\n");
return -1;
}
for (t = 0; t < maxi_pad; t++)
if (fputc(0,gwavi->out) == EOF) {
(void)fprintf(stderr, "gwavi_add_audio: fputc() failed\n");
return -1;
}
gwavi->stream_header_a.data_length += (unsigned int)(len + maxi_pad);
return 0;
}
void indexed_force_tri_3D::save(std::ofstream& out)
{
// write the label string
write_label(out, label);
// write the point cloud indices for each vertex
for (int t=0; t<3; t++)
write_int(out, p[t]);
// write the target index
write_int(out, ds_index);
// write the index list - first the length
write_int(out, grid_indices.size());
// now write all the indices
for (std::list<grid_index>::iterator it=grid_indices.begin();
it!=grid_indices.end(); it++)
{
write_int(out, it->i);
write_int(out, it->j);
write_vector(out, it->cart_coord);
}
// write the point and edge adjacency list
for (int a=0; a<2; a++)
{
write_int(out, adjacency[a].size());
for (LABEL_STORE::iterator it=adjacency[a].begin();
it!= adjacency[a].end(); it++)
write_label(out, *it);
}
}
static void
write_blocks (MonoCompile *cfg)
{
int block_size = 0;
MonoBasicBlock *bb;
for (bb = cfg->bb_entry; bb; bb = bb->next_bb)
block_size++;
write_int (cfg, block_size);
for (bb = cfg->bb_entry; bb; bb = bb->next_bb) {
int insn_size = 0;
MonoInst *insn = NULL;
write_int (cfg, bb->block_num);
for (insn = bb->code; insn; insn = insn->next)
insn_size++;
write_int (cfg, insn_size);
for (insn = bb->code; insn; insn = insn->next) {
int *id = (int *) g_hash_table_lookup (cfg->gdump_ctx->insn2id, insn);
g_assert (id);
write_int (cfg, *id);
}
write_int (cfg, bb->out_count);
for (int i = 0; i < bb->out_count; i++)
write_int (cfg, bb->out_bb[i]->block_num);
}
}
