static void waprpl_output_cb(gpointer data, gint source, PurpleInputCondition cond)
{
PurpleConnection *gc = data;
whatsapp_connection *wconn = purple_connection_get_protocol_data(gc);
char tempbuff[16*1024];
int ret;
do {
int datatosend = waAPI_sendcb(wconn->waAPI, tempbuff, sizeof(tempbuff));
if (datatosend == 0)
break;
ret = sys_write(wconn->fd, tempbuff, datatosend);
if (ret > 0) {
waAPI_senddone(wconn->waAPI, ret);
} else if (ret == 0 || (ret < 0 && errno == EAGAIN)) {
/* Check later */
} else {
gchar *tmp = g_strdup_printf("Lost connection with server (out cb): %s", g_strerror(errno));
purple_connection_error_reason(gc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp);
g_free(tmp);
break;
}
} while (ret > 0);
/* Check if we need to callback again or not */
waprpl_check_output(gc);
}
int met_start(void)
{
int i, ret;
met_node_t *tmp_node;
tmp_node = met_list;
while (tmp_node) {
ret = 0;
if (tmp_node->start) {
ret = tmp_node->start();
}
if (ret) return -1;
tmp_node = tmp_node->next;
}
for (i=0; i<mdevice_num; i++) {
char *buf[2] = { "0", "1" };
char path[64];
if ((mdevice[i].mode != 0)&&(mdevice[i].mode != 1))
continue;
snprintf(path, sizeof(path),
"/sys/class/misc/met/%s/%s/mode",
mdevice[i].type, mdevice[i].name);
sys_write(path, buf[mdevice[i].mode], 0);
}
return 0;
}
void do_syscall(TrapFrame *tf) {
switch(tf->eax) {
/* The ``add_irq_handle'' system call is artificial. We use it to
* let user program register its interrupt handlers. But this is
* very dangerous in a real operating system. Therefore such a
* system call never exists in GNU/Linux.
*/
case 0:
cli();
add_irq_handle(tf->ebx, (void*)tf->ecx);
sti();
break;
case SYS_brk: sys_brk(tf); break;
case SYS_write: sys_write(tf); break;
case SYS_read: sys_read(tf); break;
case SYS_open: sys_open(tf); break;
case SYS_lseek: sys_lseek(tf); break;
case SYS_close: sys_close(tf); break;
/* TODO: Add more system calls. */
default: panic("Unhandled system call: id = %d", tf->eax);
}
}
static void send_result(int fd, char result)
{
sys_write(fd, &result, 1);
if (result == 1) {
exit(1);
}
}
//#define USE_HW_RESET
static int lghdk_reboot_notify(struct notifier_block *nb,
unsigned long code, void *data)
{
#ifdef USE_HW_RESET
if (code == SYS_RESTART) {
/* LGE_CHANGE_S [[email protected]] 2011-01-06,
Cosmopolitan: Changed for HW reset[ST] */
static const char NVDATA_PARTITION[] = "/dev/block/platform/mmci-omap-hs.1/by-name/nv";
static const int NVDATA_RESET_OFFSET = 100;
char nvdata_reset_buffer[2] = { 0xDA };
int h_file = 0;
set_fs(KERNEL_DS);
h_file = sys_open(NVDATA_PARTITION, O_RDWR,0);
if (h_file >= 0) {
sys_lseek(h_file, NVDATA_RESET_OFFSET, 0 );
if (sys_write(h_file, nvdata_reset_buffer, 1) != 1) {
printk("Can't write Reset Bit.\n");
}
sys_close(h_file);
} else {
printk("Can't open NVDATA partition ret = %d.\n",h_file);
}
/* LGE_CHANGE_E [[email protected]] 2011-01-06 */
}
#endif
return NOTIFY_DONE;
}
asmlinkage int sunos_write(unsigned int fd, char __user *buf, int count)
{
int ret;
ret = check_nonblock(sys_write(fd,buf,count),fd);
return ret;
}
static void mdm_restart_reason_fn(struct work_struct *work)
{
int ret, ntries = 0;
char sfr_buf[RD_BUF_SIZE];
do {
msleep(SFR_RETRY_INTERVAL);
ret = sysmon_get_reason(SYSMON_SS_EXT_MODEM,
sfr_buf, sizeof(sfr_buf));
if (ret) {
/*
* The sysmon device may not have been probed as yet
* after the restart.
*/
pr_err("%s: Error retrieving mdm restart reason, ret = %d, "
"%d/%d tries\n", __func__, ret,
ntries + 1, SFR_MAX_RETRIES);
} else {
// ASUS_BSP+++ Wenli "Modify for modem restart"
#ifndef ASUS_SHIP_BUILD
int file_handle;
mm_segment_t oldfs;
oldfs = get_fs();
set_fs(KERNEL_DS);
file_handle = sys_open("/data/log/modem_crash.log", O_CREAT|O_WRONLY|O_SYNC|O_TRUNC, 0644);
if(!IS_ERR((const void *)file_handle))
{
ret = sys_write(file_handle, sfr_buf, strlen(sfr_buf));
sys_close(file_handle);
}
// Save reason on
file_handle = sys_open("/data/log/RAMDump0/reason.log", O_CREAT|O_WRONLY|O_SYNC|O_TRUNC, 0644);
if(!IS_ERR((const void *)file_handle))
{
ret = sys_write(file_handle, sfr_buf, strlen(sfr_buf));
sys_close(file_handle);
}
set_fs(oldfs);
#endif
// ASUS_BSP--- Wenli "Modify for modem restart"
ASUSEvtlog("SSR %s\n", sfr_buf);
pr_err("mdm restart reason: %s\n", sfr_buf);
break;
}
} while (++ntries < SFR_MAX_RETRIES);
}
static int ce1702_isp_event_store(struct device* dev, struct device_attribute* attr, const char* buf, size_t n)
{
int val;
struct timespec time;
struct tm tm_result;
uint8_t filename[128];
time = __current_kernel_time();
time_to_tm(time.tv_sec, sys_tz.tz_minuteswest * 60 * (-1), &tm_result);
sprintf(filename, "/data/event_%02d%02d%02d%02d%02d.bin", tm_result.tm_mon + 1, tm_result.tm_mday, tm_result.tm_hour, tm_result.tm_min, tm_result.tm_sec);
sscanf(buf,"%x", &val);
if (val) {
int32_t rc, num_read;
uint8_t data[130];
uint8_t packet_size[2] = {0, };
rc = ce1702_i2c_read(ce1702_s_interface_ctrl->sensor_i2c_addr, 0xDB, NULL, 0, packet_size, 2);
if (rc < 0)
{
LDBGE("%s: num_read reading error\n", __func__);
return n;
}
num_read = packet_size[0] + (packet_size[1] << 8);
LDBGE("%s: num_read : %d, [%x|%x]\n", __func__, num_read, packet_size[0], packet_size[1]);
if (num_read > 0) {
mm_segment_t old_fs;
uint8_t *dump_data;
int32_t dump_data_len, nloop, fd;
dump_data_len = num_read * 128 * sizeof(uint8_t);
dump_data = kmalloc(dump_data_len, GFP_KERNEL);
for (nloop = 0; nloop < num_read; nloop++)
{
rc = ce1702_i2c_read(ce1702_s_interface_ctrl->sensor_i2c_addr, 0xDC, NULL, 0, data, 130);
if (rc < 0) {
LDBGE("%s: %d-th reading error\n", __func__, nloop);
continue;
}
memcpy(&dump_data[nloop * 128], &data[2], sizeof(uint8_t) * 128);
}
old_fs = get_fs();
set_fs(KERNEL_DS);
fd = sys_open(filename, O_RDWR | O_CREAT , 0644);
if (fd >= 0) {
sys_write(fd, dump_data, dump_data_len);
sys_close(fd);
LDBGE("%s: isp eventlog (%s) successfully writed (%d)!! \n", __func__, filename, nloop);
}
set_fs(old_fs);
kfree(dump_data);
}
}
return n;
}
/*
* Description :
* Input :
* Output :
*/
int felica_i2c_read(unsigned char reg, unsigned char *buf, size_t count)
{
ssize_t rc = 0;
mm_segment_t old_fs = get_fs();
#ifdef FEATURE_DEBUG_LOW
FELICA_DEBUG_MSG("[FELICA_I2C] felica_i2c_read\n");
#endif
set_fs(KERNEL_DS);
/* dev/i2c-0 device file open */
rc = felica_i2c_open();
if (rc)
{
FELICA_DEBUG_MSG("[FELICA_I2C] ERROR - felica_i2c_open : %d \n",rc);
return rc;
}
/* Set slave address */
rc = felica_i2c_set_slave_address(I2C_FELICA_SLAVE_ADDRESS);
if (rc)
{
FELICA_DEBUG_MSG("[FELICA_I2C] ERROR - felica_i2c_set_slave_address : %d \n",rc);
return rc;
}
/* set register address */
rc = sys_write(fd, ®, 1);
if (rc < 0)
{
FELICA_DEBUG_MSG("[FELICA_I2C] ERROR - sys_write : %d \n",rc);
return rc;
}
/* read register data */
rc = sys_read(fd, buf, count);
#ifdef FEATURE_DEBUG_LOW
FELICA_DEBUG_MSG("[FELICA_I2C] read data : 0x%02x \n",*buf);
#endif
if (rc < 0)
{
FELICA_DEBUG_MSG("[FELICA_I2C] ERROR - sys_read : %d \n",rc);
return rc;
}
/* release i2c */
rc = felica_i2c_release();
if (rc)
{
FELICA_DEBUG_MSG("[FELICA_I2C] ERROR - felica_i2c_release : %d \n",rc);
return rc;
}
set_fs(old_fs);
return 0;
}
/*****************************************************************************
函 数 名 : acm_async_write
功能描述 : acm写函数，非阻塞接口
输入参数 : int acm_dev : 对象设备
unsigned char *pbuff : 传入buffer的首地址
unsigned int size : 源数据的字节数
输出参数 : 无
返 回 值 : int
调用函数 :
被调函数 :
修改历史 :
1.日 期 : 2012年9月13日
作 者 : 夏青 00195127
修改内容 : 新生成函数
*****************************************************************************/
int acm_async_write(void *acm_dev, char *pVirAddr, char *pPhyAddr, unsigned int size)
{
long fd;
int len = (int)ADP_ERROR;
mm_segment_t fs = 0;
struct acm_ctx *p_acm_ctx = (struct acm_ctx *)acm_dev;
struct acm_ncopy_ctx * acm_ncpy = (struct acm_ncopy_ctx *)p_acm_ctx->acm_ncpy;
int rc = ADP_OK;
ACM_ADP_DBG(" acm[%s] pVirAddr[%p] pPhyAddr[%p]size[%d]\n",
p_acm_ctx->tty_name, pVirAddr, pPhyAddr, size);
if (!p_acm_ctx->bopen) {
ACM_ADP_ERR("acm[%s] device is not opened\n", p_acm_ctx->tty_name);
return ADP_ERROR;
}
if ((NULL == pVirAddr) || (size == 0)) {
ACM_ADP_ERR("acm[%s] para is invalid\n", p_acm_ctx->tty_name);
return ADP_ERROR;
}
if (p_acm_ctx->ncopy) {
#ifndef _DRV_LLT_
if((0 == p_acm_ctx->phyaddr_from_app)||(NULL == pPhyAddr)){
pPhyAddr = (char *)dma_map_single(acm_ncpy->tty->dev,(void *)pVirAddr,size,DMA_TO_DEVICE);
}
#endif
rc = acm_ncopy_start_tx((void *)p_acm_ctx, pVirAddr, pPhyAddr, size);
if (ADP_OK == rc) {
len = size;
}
} else {
/* 根据acm_dev_id获得设备对应tty设备fd */
fd = p_acm_ctx->fd;
fs = get_fs();
set_fs(KERNEL_DS);
/* 设置NONBLOCK标志位 */
sys_fcntl(fd, F_SETFL, O_NONBLOCK);
/* 调用fd的write写入数据，并且得到返回值，返回值为写数据的长度len */
len = sys_write(fd, pVirAddr, size);
set_fs(fs);
if (len == size) {
if (p_acm_ctx->writeDoneCB) {
ACM_ADP_DBG(" acm[%s] cb len[%d]\n", p_acm_ctx->tty_name, len);
p_acm_ctx->writeDoneCB(pVirAddr, pPhyAddr, len);
}
}
}
ACM_ADP_DBG(" acm[%s] len[0x%x]\n", p_acm_ctx->tty_name, len);
return len;
}
static void __fifo_send(const char* dev, void* ptr, size_t size) {
int fd = sys_open(dev, O_WRONLY, 0);
if(fd < 0)
return;
sys_write(fd, ptr, size);
sys_close(fd);
}
solo5_result_t solo5_net_write(const uint8_t *buf, size_t size)
{
assert(netfd >= 0);
long nbytes = sys_write(netfd, (const char *)buf, size);
return (nbytes == (int)size) ? SOLO5_R_OK : SOLO5_R_EUNSPEC;
}
static int socket_client_write(int client)
{
if (sys_write(client, "\0", 1) == -1) {
DEBUG(DEBUG_CRIT,("Unable to write to client socket: %s\n", strerror(errno)));
return -1;
}
return 0;
}
void print(const char* buffer) {
int fd = sys_open(SYSTEM_SERIAL_0_PATH, SYSTEM_FLAG_WRITE);
if (fd != SYSTEM_FD_INVALID) {
sys_write(fd, buffer, strlen(buffer));
// do not close serial 0!
//sys_close(fd);
}
}
/*
* local file write
*/
s32 nv_lfile_write(u8* ptr,u32 size,u32 count,FILE* fp)
{
#ifdef __KERNEL__
return sys_write(fp,ptr,(size*count));
#else
return fwrite(ptr,size,count,fp);
#endif
}
static int pmuL2_check_arg(met_context_t *ctx)
{
if ((toggle_mode==1) && (l2_idx!=0)) {
printf("!!! ERROR: \"pmu-l2-toggle\" can not work with \"pmu-l2-evt\" options !!!\n");
return -1;
}
qsort(l2_pmu, l2_idx, sizeof(struct pmu_struct), compare);
if ((toggle_mode==1) || (l2_idx!=0)){
sys_write("/sys/class/misc/met/pmu/l2/mode", "1", 0);
} else {
sys_write("/sys/class/misc/met/pmu/l2/mode", "0", 0);
}
return 0;
}
static bool send_pcap_blob(DATA_BLOB *pcap_blob, int fd)
{
size_t ret;
ret = sys_write(fd, &pcap_blob->length, sizeof(pcap_blob->length));
if (ret != sizeof(pcap_blob->length)) {
return false;
}
ret = sys_write(fd, pcap_blob->data, pcap_blob->length);
if (ret != pcap_blob->length) {
return false;
}
DEBUG(10, ("successfully sent blob of len %d\n", (int)ret));
return true;
}
static int connect_to_adb_and_start_tracking(void)
{
bool t_success;
t_success = true;
struct sockaddr_in t_server;
memset(&t_server, 0, sizeof(t_server));
t_server . sin_family = AF_INET;
t_server . sin_port = htons(5037);
t_server . sin_addr.s_addr = htonl(INADDR_LOOPBACK);
int t_socket;
t_socket = -1;
if (t_success)
{
t_socket = socket(PF_INET, SOCK_STREAM, 0);
if (t_socket < 0)
t_success = false;
}
if (t_success)
{
struct timeval tv;
tv . tv_sec = 0;
tv . tv_usec = 500 * 1000;
setsockopt(t_socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv));
}
if (t_success)
if (connect(t_socket, (struct sockaddr*)&t_server, sizeof(t_server)) < 0)
t_success = false;
if (t_success)
{
const char *t_request = "host:track-devices";
char t_buffer[64];
sprintf(t_buffer, "%04x%s", (unsigned int)strlen(t_request), t_request);
if (sys_write(t_socket, t_buffer, strlen(t_buffer)) < 0)
t_success = false;
}
if (t_success)
{
char t_buffer[4];
if (sys_read(t_socket, t_buffer, 4) != 4 ||
memcmp(t_buffer, "OKAY", 4) != 0)
t_success = false;
}
if (!t_success)
{
if (t_socket != -1)
sys_close(t_socket);
t_socket = -1;
}
return t_socket;
}
void
vfdbnprintf(int fd, char * buffer, size_t buf_sz,
const char * fmt, va_list args)
{
int r = vsnprintf(buffer, buf_sz, fmt, args);
if (r > 0)
sys_write(fd, buffer,
r > buf_sz ? buf_sz : r);
}
static void write_str(const char *str)
{
int len = 0;
while (str[len])
len++;
sys_write(current_logfd, str, len);
}
int
sys_penguin_write(struct penguin_write_args *args)
{
kprintf("sys_write, %x, count, %lu\n", args->fd, args->count);
int error = sys_write((void*)args);
kprintf("sys_write returns error %d\n", error);
args->sysmsg_result64 = error;
return 0;
}
int set_acl_enable(int val)
{
int fd = 0;
unsigned char buf0[2]="0";
unsigned char buf1[2]="1";
fd = sys_open("/sys/class/lcd/panel/siop_enable", O_RDWR, 0);
if(fd > 0){
if(val==0)
sys_write(fd, buf0, 2);
else
sys_write(fd, buf1, 2);
sys_close(fd);
}
return 0;
}
int mntn_do_save_virtual_addr_log(unsigned char *viradd, unsigned int ulen, const char *ppath, const char *pfilename)
{
int iret = 0;
char fullpath_arr[MNTN_FULLPATH_STRING_LEN + 1] = {0};
long fd = 0;
int bytes = 0;
unsigned char *pdatabuf = viradd;
mm_segment_t old_fs = 0;
if (NULL == pdatabuf || NULL == viradd || NULL == pfilename)
{
MNTN_FILESYS_PRINT(KERN_ERR"mntn_err: some parameter is NULL!\n");
return -1;
}
MNTN_FILESYS_PRINT(KERN_ERR"mntn_do_save_virtual_addr_log: viradd %p, length is %d\n", viradd, ulen);
/*Write reset reason into history.log*/
memset(fullpath_arr, 0, MNTN_FULLPATH_STRING_LEN);
strncat(fullpath_arr, ppath, strlen(ppath));
strncat(fullpath_arr, pfilename, strlen(pfilename));
old_fs = get_fs();
set_fs(KERNEL_DS);
fd = sys_open(fullpath_arr, O_CREAT | O_RDWR, MNTN_LOG_FILE_PRO_VALUE);
if (fd < 0)
{
MNTN_FILESYS_PRINT(KERN_ERR"mntn_err: Fail to open %s!, fd %lx\n", pfilename, fd);
set_fs(old_fs);
iret = -1;
goto oper_over2;
}
bytes = sys_write(fd, (void*)pdatabuf, ulen);
if (bytes != ulen)
{
MNTN_FILESYS_PRINT(KERN_ERR"mntn_err: Fail to write all the data into the file, %d/%d\n", bytes, ulen);
iret = -1;
goto oper_over1;
}
iret = sys_fsync(fd);
if (iret < 0)
{
MNTN_FILESYS_PRINT(KERN_ERR"mntn_err: Fail to sys_fsync data\n");
goto oper_over1;
}
iret += mntn_filesys_chown((const char *)fullpath_arr, MNTN_LOG_FILE_OWNER_UID, MNTN_LOG_FILE_OWNER_GID);
if (0 != iret)
{
MNTN_FILESYS_PRINT(KERN_ERR"mntn_err: Fail to chown history.log!\n");
}
oper_over1:
(void)sys_close((unsigned int)fd);
oper_over2:
set_fs(old_fs);
MNTN_FILESYS_PRINT(KERN_ERR"mntn_do_save_virtual_addr_log: over\n");
return iret;
}
/*
* Description :
* Input :
* Output :
*/
int felica_i2c_write(unsigned char reg, unsigned char *buf, size_t count)
{
ssize_t rc = 0;
unsigned char write_buf[2];
mm_segment_t old_fs = get_fs();
#ifdef FEATURE_DEBUG_LOW
FELICA_DEBUG_MSG("[FELICA_I2C] felica_i2c_write\n");
#endif
set_fs(KERNEL_DS);
/* dev/i2c-0 device file open */
rc = felica_i2c_open();
if (rc)
{
FELICA_DEBUG_MSG("[FELICA_I2C] ERROR - felica_i2c_open : %d \n",rc);
return rc;
}
/* set slave address */
rc = felica_i2c_set_slave_address(I2C_FELICA_SLAVE_ADDRESS);
if (rc)
{
FELICA_DEBUG_MSG("[FELICA_I2C] ERROR - felica_i2c_set_slave_address : %d \n",rc);
return rc;
}
/* set register */
memset(write_buf,0x00,2*sizeof(unsigned char));
write_buf[0] = reg;
write_buf[1] = *buf;
#ifdef FEATURE_DEBUG_LOW
FELICA_DEBUG_MSG("[FELICA_I2C] write_buf[0][1] : 0x%02x 0x%02x \n",write_buf[0],write_buf[1]);
#endif
/* write data */
rc = sys_write(fd, write_buf, 2);
if (rc < 0)
{
FELICA_DEBUG_MSG("[FELICA_I2C] ERROR - sys_write : %d \n",rc);
return rc;
}
/* release i2c */
rc = felica_i2c_release();
if (rc)
{
FELICA_DEBUG_MSG("[FELICA_I2C] ERROR - felica_i2c_release : %d \n",rc);
return rc;
}
set_fs(old_fs);
return 0;
}
int snfc_i2c_write(unsigned char reg, unsigned char *buf, size_t count)
{
ssize_t rc = 0;
unsigned char write_buf[2];
mm_segment_t old_fs = get_fs();
SNFC_DEBUG_MSG_LOW("[snfc_i2c] snfc_i2c_write\n");
set_fs(KERNEL_DS);
/* */
rc = snfc_i2c_open();
if (rc)
{
SNFC_DEBUG_MSG("[snfc_i2c] ERROR - snfc_i2c_open : %d \n",rc);
__snfc_i2c_control_set_status(I2C_STATUS_READY);
return rc;
}
/* */
rc = snfc_i2c_set_slave_address(I2C_SNFC_SLAVE_ADDRESS);
if (rc)
{
SNFC_DEBUG_MSG("[snfc_i2c] ERROR - snfc_i2c_set_slave_address : %d \n",rc);
__snfc_i2c_control_set_status(I2C_STATUS_READY);
return rc;
}
/* */
memset(write_buf,0x00,2*sizeof(unsigned char));
write_buf[0] = reg;
write_buf[1] = *buf;
SNFC_DEBUG_MSG_LOW("[snfc_i2c] write_buf[0][1] : 0x%02x 0x%02x \n",write_buf[0],write_buf[1]);
/* */
rc = sys_write(fd, write_buf, 2);
if (rc < 0)
{
SNFC_DEBUG_MSG("[snfc_i2c] ERROR - sys_write : %d \n",rc);
__snfc_i2c_control_set_status(I2C_STATUS_READY);
return rc;
}
/* */
rc = snfc_i2c_release();
if (rc)
{
SNFC_DEBUG_MSG("[snfc_i2c] ERROR - snfc_i2c_release : %d \n",rc);
__snfc_i2c_control_set_status(I2C_STATUS_READY);
return rc;
}
set_fs(old_fs);
return 0;
}
ssize_t vfswrap_write(vfs_handle_struct *handle, files_struct *fsp, int fd, const void *data, size_t n)
{
ssize_t result;
START_PROFILE_BYTES(syscall_write, n);
result = sys_write(fd, data, n);
END_PROFILE(syscall_write);
return result;
}
extern int tbuf_write(TBuf *b, IO *io)
{
char data_buf[MAX_BLOCK];
char *p = data_buf;
int used = 0, count = 0;
Tuple *t;
tbuf_reset(b);
while ((t = tbuf_next(b)) != NULL) {
used = p - data_buf;
if (MAX_BLOCK - used < t->size) {
if (sys_write(io, &used, sizeof(used)) < 0 ||
sys_write(io, data_buf, used) < 0)
goto failure;
p = data_buf;
}
p += tuple_enc(t, p);
tuple_free(t);
count++;
}
used = p - data_buf;
if (sys_write(io, &used, sizeof(used)) < 0)
goto failure;
if (used > 0) {
if (sys_write(io, data_buf, used) < 0)
goto failure;
used = 0;
if (sys_write(io, &used, sizeof(used)) < 0)
goto failure;
}
return count;
failure:
while ((t = tbuf_next(b)) != NULL)
tuple_free(t);
return -1;
}
void printi(int num)
{
char str[10];
int i = 0;
//fem itoa() mentre no arribem al final del num
str[0] = (char)(num % 10 + 48);
while (num /= 10) str[++i]=(char)(num % 10 + 48);
//fem write del resultat convertit
for (i=i;i>=0;i--) sys_write(1,&str[i],1);
}
void write_str_n_on_level(unsigned int loglevel, char *str)
{
char new_line = '\n';
if (loglevel > current_loglevel)
return;
write_str(str);
sys_write(current_logfd, &new_line, 1);
}
void write_num_n_on_level(unsigned int loglevel, long num)
{
unsigned char c = '\n';
if (loglevel > current_loglevel)
return;
write_num(num);
sys_write(current_logfd, &c, sizeof(c));
}
