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)); }