void
umain(void)
{
envid_t who;
if ((who = fork()) != 0) {
// get the ball rolling
cprintf("send 0 from %x to %x\n", sys_getenvid(), who);
ipc_send(who, 0, 0, 0);
}
while (1) {
uint32_t i = ipc_recv(&who, 0, 0);
cprintf("%x got %d from %x\n", sys_getenvid(), i, who);
if (i == 10)
return;
i++;
ipc_send(who, i, 0, 0);
if (i == 10)
return;
}
}
// Reconnect the given socket. Only works for UDP datagram streams.
return_type ipv4_reconnect(ipc_structure_type *ipv4_structure, ipv4_reconnect_type *connect)
{
message_parameter_type message_parameter;
message_parameter.protocol = IPC_PROTOCOL_IPV4;
message_parameter.message_class = IPC_IPV4_RECONNECT;
message_parameter.data = connect;
message_parameter.length = sizeof(ipv4_reconnect_type);
message_parameter.block = TRUE;
ipc_send(ipv4_structure->output_mailbox_id, &message_parameter);
return IPV4_RETURN_SUCCESS;
}
void
serve_remove(u_int envid, struct Fsreq_remove *rq)
{
int r = 0;
u_char path[MAXPATHLEN];
if (debug) printf("serve_remove %08x %s\n", envid, rq->req_path);
memcpy(path, rq->req_path, MAXPATHLEN);
r = file_remove(path);
ipc_send(envid, r, 0, 0);
// Your code here
//panic("serve_remove not implemented");
}
static int
xopen(const char *path, int mode)
{
extern union Fsipc fsipcbuf;
envid_t fsenv;
strcpy(fsipcbuf.open.req_path, path);
fsipcbuf.open.req_omode = mode;
fsenv = ipc_find_env(ENV_TYPE_FS);
ipc_send(fsenv, FSREQ_OPEN, &fsipcbuf, PTE_P | PTE_W | PTE_U);
return ipc_recv(NULL, FVA, NULL);
}
/*
* Parse a command of arbitrary length, execute it, place result in *ret.
*/
void ipc_run(int handle, struct ipc_ret_t *ret, const char *fmt, ...)
{
va_list ap;
char *buffer;
int iret;
assert(fmt);
va_start(ap, fmt);
iret = vasprintf(&buffer, fmt, ap);
assert(iret>=0);
va_end(ap);
assert(buffer);
ipc_send(handle, buffer, strlen(buffer),ret);
free(buffer);
}
void
serve_dirty(u_int envid, struct Fsreq_dirty *rq)
{
struct Open *o;
int r;
if (debug) printf("serve_dirty %08x %08x %08x\n", envid, rq->req_fileid, rq->req_offset);
if((r = open_lookup(envid, rq->req_fileid, &o)) < 0)
goto out_dirty;
r = file_dirty(&o->o_ff->f_file, rq->req_offset);
out_dirty:
ipc_send(envid, r, 0, 0);
// Your code here
// panic("serve_dirty not implemented");
}
void
umain(void)
{
u_int who, i;
if ((who = fork()) != 0) {
// get the ball rolling
printf("send 0 from %x to %x\n", sys_getenvid(), who);
ipc_send(who, 0, 0, 0);
}
for (;;) {
i = ipc_recv(&who, 0, 0);
printf("%x got %d from %x\n", sys_getenvid(), i, who);
if (i == 10)
return;
i++;
ipc_send(who, i, 0, 0);
if (i == 10)
return;
}
}
void
serve_remove(u_int envid, struct Fsreq_remove *rq)
{
if (debug) {
writef("serve_map %08x %s\n", envid, rq->req_path);
}
// Your code here
int r;
u_char path[MAXPATHLEN];
// Copy in the path, making sure it's null-terminated
user_bcopy(rq->req_path, path, MAXPATHLEN);
path[MAXPATHLEN - 1] = 0;
if ((r = file_remove((char *)path)) < 0) {
ipc_send(envid, r, 0, 0);
return;
}
ipc_send(envid, 0, 0, 0);//PTE_V);
// user_panic("serve_remove not implemented");
}
void
serve_close(u_int envid, struct Fsreq_close *rq)
{
struct Open *o;
int r = 0;
if (debug) printf("serve_close %08x %08x\n", envid, rq->req_fileid);
if((r = open_lookup(envid, rq->req_fileid, &o)) < 0)
goto out_close;
file_close(&o->o_ff->f_file);
out_close:
ipc_send(envid, r, 0, 0);
// Your code here
// panic("serve_close not implemented");
}
void lbs_send_packet(uint32_t type, uint32_t size, uint32_t subType, void* buf)
{
struct modem_io pkt;
struct lbsPacketHeader* hdr;
void* sendBuf;
sendBuf = (void*) lbsSendBuf;
hdr = (struct lbsPacketHeader*) &lbsSendBuf;
/* BIG WTF at the lengths below, shitload of uninitialized, redundant data
* OHAI retarded Samsung devs */
if(type <= 6 || (type >= 21 && type <= 30)) //common 1
pkt.datasize = 0x100C;
else if((type >= 7 && type <= 12) ||
(type >= 31 && type <= 35)) //supl 2
pkt.datasize = 0x81C;
else if((type >= 13 && type <= 14) ||
(type >= 16 && type <= 18) ||
(type >= 36 && type <= 39)) //xtra 3
pkt.datasize = 0x3C;
else if(type == 15) //large_xtra 5
{
sendBuf = malloc(0xA014);
pkt.datasize = 0xA014;
}
else if(type == 19 || type == 20) //baseband 5
pkt.datasize = 0xDC;
else
{
DEBUG_E("Unknown LBS packet type, abandoning...");
return;
}
if(size > pkt.datasize - sizeof(struct lbsPacketHeader))
{
DEBUG_E("Too big LBS packet, type %d, len %d", type, size);
return;
}
hdr->type = type;
hdr->size = size;
hdr->subType = subType;
memcpy((char*)(sendBuf) + sizeof(struct lbsPacketHeader), buf, size);
pkt.magic = 0xCAFECAFE;
pkt.cmd = FIFO_PKT_LBS;
pkt.data = sendBuf;
ipc_send(&pkt);
if(type == 15)
free(sendBuf);
}
void
serve_map(envid_t envid, struct Fsreq_map *rq)
{
int r;
char *blk;
struct OpenFile *o;
int perm = PTE_U | PTE_P | PTE_AVAIL;
uint32_t *pdiskbno;
if (debug)
cprintf("serve_map %08x %08x %08x\n", envid,
rq->req_fileid, rq->req_offset);
// Map the requested block in the client's address space
// by using ipc_send.
// Map read-only unless the file's open mode (o->o_mode) allows writes
// (see the O_ flags in inc/lib.h).
// LAB 5: Your code here.
r = openfile_lookup(envid, rq->req_fileid, &o);
if (r<0) {
cprintf("serv.c:serve_map--openfile_lookup failed.\n");
ipc_send(envid, r, 0, 0);
return;
}
r = file_get_block(o->o_file, rq->req_offset, &blk);
if (r<0) {
cprintf("serv.c:serve_map--file_get_walk failed.\n");
goto out;
}
if (o->o_mode&O_RDWR) {//what happens if O_WRONLY?
perm = PTE_USER;
}
out:
ipc_send(envid, r, blk, perm);
//panic("serve_map not implemented");
}
void
serve_close(u_int envid, struct Fsreq_close *rq)
{
if (debug) {
writef("serve_close %08x %08x\n", envid, rq->req_fileid);
}
struct Open *pOpen;
int r;
if ((r = open_lookup(envid, rq->req_fileid, &pOpen)) < 0) {
ipc_send(envid, r, 0, 0);
return;
}
//writef("serve_close:pOpen = %x\n",pOpen);
file_close(pOpen->o_file);
ipc_send(envid, 0, 0, 0);//PTE_V);
// syscall_mem_unmap(0, (u_int)pOpen);
return;
// user_panic("serve_close not implemented");
}
// Get the host name of the system.
return_type ipv4_host_name_get(ipc_structure_type *ipv4_structure, char *host_name)
{
message_parameter_type message_parameter;
message_parameter.protocol = IPC_PROTOCOL_IPV4;
message_parameter.message_class = IPC_IPV4_GET_HOST_NAME;
message_parameter.data = host_name;
message_parameter.length = 0;
ipc_send(ipv4_structure->output_mailbox_id, &message_parameter);
message_parameter.length = IPV4_HOST_NAME_LENGTH;
ipc_receive(ipv4_structure->input_mailbox_id, &message_parameter, NULL);
return IPV4_RETURN_SUCCESS;
}
// Send an inter-environment request to the file server, and wait for
// a reply. The request body should be in fsipcbuf, and parts of the
// response may be written back to fsipcbuf.
// type: request code, passed as the simple integer IPC value.
// dstva: virtual address at which to receive reply page, 0 if none.
// Returns result from the file server.
static int
fsipc(unsigned type, void *dstva)
{
static envid_t fsenv;
if (fsenv == 0)
fsenv = ipc_find_env(ENV_TYPE_FS);
static_assert(sizeof(fsipcbuf) == PGSIZE);
if (debug)
cprintf("[%08x] fsipc %d %08x\n", thisenv->env_id, type, *(uint32_t *)&fsipcbuf);
ipc_send(fsenv, type, &fsipcbuf, PTE_P | PTE_W | PTE_U);
return ipc_recv(NULL, dstva, NULL);
}
void
umain(void)
{
int i, id;
// fork the first prime process in the chain
if ((id=fork()) < 0)
panic("fork: %e", id);
if (id == 0)
primeproc();
// feed all the integers through
for (i=2;; i++)
ipc_send(id, i, 0, 0);
}
void
ipc_recv_extension_init(ipc_endpoint_t *ipc, const gpointer UNUSED(msg), guint UNUSED(length))
{
web_module_load_modules_on_endpoint(ipc);
/* Notify web extension that pending signals can be released */
ipc_header_t header = { .type = IPC_TYPE_extension_init, .length = 0 };
ipc_send(ipc, &header, NULL);
}
void
ipc_recv_lua_ipc(ipc_endpoint_t *UNUSED(ipc), const ipc_lua_ipc_t *msg, guint length)
{
ipc_channel_recv(common.L, msg->arg, length);
}
void
serve_set_size(u_int envid, struct Fsreq_set_size *rq)
{
struct Open *o;
int r = 0;
if (debug) printf("serve_set_size %08x %08x %08x\n", envid, rq->req_fileid, rq->req_size);
if((r = open_lookup(envid, rq->req_fileid, &o)) < 0)
goto out_set_size;
r = file_set_size(&o->o_ff->f_file, rq->req_size);
if(r == 0)
o->o_file->f_size = rq->req_size;
out_set_size:
ipc_send(envid, r, 0, 0);
// Your code here
// panic("serve_set_size not implemented");
}
void answer_error_to_client(int err_code, int client_id){
ipc_params_t client_params;
status client_program;
client_params = get_params_from_pid(client_id, PROGRAM_STATUS, sizeof(struct status), server_params->semid);
client_params->socklistener = TRUE;
client_program.flag = err_code;
printf("Answering to client: %d\n", client_id);
ipc_open(client_params, O_WRONLY);
ipc_send(client_params, &client_program, sizeof(struct status));
ipc_close(client_params);
free(client_params->file);
free(client_params);
}
// Send a proof over IPC
void send_proof(envid_t to, Proof p) {
// Copy the proof to UTEMP
sys_page_alloc(0, UTEMP, PTE_U | PTE_W);
Heap tempHeap;
init_heap(&tempHeap, UTEMP, PGSIZE);
Heap *oldHeap = set_heap(&tempHeap);
Proof copy = proof_cp(p);
size_t offset = (uintptr_t)copy - (uintptr_t)UTEMP;
// Send the proof
ipc_send(to, offset, UTEMP, PTE_U);
sys_page_unmap(0, UTEMP);
// Reset the heap
set_heap(oldHeap);
}
// Get flags.
return_type ipv4_get_flags(ipc_structure_type *ipv4_structure, unsigned int *flags)
{
message_parameter_type message_parameter;
message_parameter.protocol = IPC_PROTOCOL_IPV4;
message_parameter.message_class = IPC_IPV4_GET_FLAGS;
message_parameter.data = flags;
message_parameter.length = 0;
message_parameter.block = TRUE;
ipc_send(ipv4_structure->output_mailbox_id, &message_parameter);
message_parameter.length = sizeof(unsigned int);
ipc_receive(ipv4_structure->input_mailbox_id, &message_parameter, NULL);
return IPV4_RETURN_SUCCESS;
}
static void
process_timer(envid_t envid) {
uint32_t start, now, to;
if (envid != timer_envid) {
cprintf("NS: received timer interrupt from envid %x not timer env\n", envid);
return;
}
start = sys_time_msec();
thread_yield();
now = sys_time_msec();
to = TIMER_INTERVAL - (now - start);
ipc_send(envid, to, 0, 0);
}
// Mark the page containing the requested file offset as dirty.
void
serve_dirty(envid_t envid, struct Fsreq_dirty *rq)
{
struct OpenFile *o;
int r;
if (debug)
cprintf("serve_dirty %08x %08x %08x\n", envid, rq->req_fileid, rq->req_offset);
if ((r = openfile_lookup(envid, rq->req_fileid, &o)) < 0)
goto out;
r = file_dirty(o->o_file, rq->req_offset);
out:
ipc_send(envid, r, 0, 0);
}
static int
send_result(int cmd, const char *data, size_t size)
{
ipc_start(cmd, chan, chan_id, 0);
if (CMD_RESULT == cmd) {
if (bk_app)
ipc_pack_arg(bk_app, strlen(bk_app));
else
ipc_pack_arg("comar", 5);
}
if (data) {
if (size == 0) size = strlen(data);
ipc_pack_arg(data, size);
}
ipc_send(TO_PARENT);
return 0;
}
static int http_post_mp4(char *file, char *obdid, char *token, char *eventid, char *cameraid,
char *ip, int port, char *address)
{
int bound_len = strlen(BOUNDARY_S) + strlen(FILE_NAME) + strlen(file) + \
strlen(FILE_TYPE_MP4) + strlen(BOUNDARY_E) - 2;
struct stat stat;
int len;
char *data;
ssize_t val;
char md5[48];
file_md5(file, md5, sizeof(md5));
int fd = open(file, O_RDONLY);
if (fd < 0) {
return -1;
}
fstat(fd, &stat);
data = (char *) malloc(512 + stat.st_size);
memset(data, 0, (512 + stat.st_size));
len = sprintf(data, METHOD, address, obdid, eventid, token, md5, cameraid);
len += sprintf(data + len, USER_AGENT);
len += sprintf(data + len, CON_LEN, bound_len + (int)stat.st_size);
len += sprintf(data + len, CON_TYPE);
len += sprintf(data + len, BOUNDARY_S);
len += sprintf(data + len, FILE_NAME, file);
len += sprintf(data + len, FILE_TYPE_MP4);
val = read(fd, (void *)(data + len), stat.st_size);
close(fd);
if (val < 0){
free(data);
return -1;
}
len += val;
len += sprintf(data + len , "%s", BOUNDARY_E);
int skt;
int res;
skt = ipc_connect(ip, port);
if (skt < 0)
return -1;
res = ipc_send(skt, (char *)data, len);
close(skt);
free(data);
return res;
}
void
serve_close(envid_t envid, struct Fsreq_close *rq)
{
struct OpenFile *o;
int r;
if (debug)
cprintf("serve_close %08x %08x\n", envid, rq->req_fileid);
if ((r = openfile_lookup(envid, rq->req_fileid, &o)) < 0)
goto out;
file_close(o->o_file);
r = 0;
out:
ipc_send(envid, r, 0, 0);
}
/**
* In: RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND
* Requests to send a SAT/USAT envelope command to SIM.
* The SAT/USAT envelope command refers to 3GPP TS 11.14 and 3GPP TS 31.111
*
* Out: IPC_SAT_ENVELOPE_CMD EXEC
*/
void requestSatSendEnvelopeCommand(RIL_Token t, void *data, size_t datalen)
{
unsigned char buf[264];
int len = (strlen(data) / 2);
if(len > 255) {
ALOGE("%s: data exceeds maximum length", __FUNCTION__);
ril_request_complete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
}
memset(buf, 0, sizeof(buf));
buf[0] = len;
hex2bin(data, strlen(data), &buf[1]);
ipc_send(IPC_SAT_ENVELOPE_CMD, IPC_TYPE_EXEC, buf, sizeof(buf), reqGetId(t));
}
void
serve_remove(envid_t envid, struct Fsreq_remove *rq)
{
char path[MAXPATHLEN];
int r;
if (debug)
cprintf("serve_remove %08x %s\n", envid, rq->req_path);
// Copy in the path, making sure it's null-terminated
memmove(path, rq->req_path, MAXPATHLEN);
path[MAXPATHLEN-1] = 0;
// Delete the specified file
r = file_remove(path);
ipc_send(envid, r, 0, 0);
}
void
umain(void)
{
envid_t who, id;
id = sys_getenvid();
if (env == &envs[1]) {
while (1) {
ipc_recv(&who, 0, 0);
cprintf("%x recv from %x\n", id, who);
}
} else {
cprintf("%x loop sending to %x\n", id, envs[1].env_id);
while (1)
ipc_send(envs[1].env_id, 0, 0, 0);
}
}
// Buffer cache IPC helper function.
// Send a buffer cache 'reqtype' IPC (one of the BCREQ_ constants)
// for the file system block containing 'addr'.
// Returns 0 on success, < 0 on error.
//
static int
bcache_ipc(void *addr, int reqtype)
{
int r;
blocknum_t b = ((uintptr_t) addr - FSMAP) / BLKSIZE;
if (b < 0 || b > (blocknum_t) (DISKSIZE / BLKSIZE))
panic("bcache_ipc: va %08x out of disk address range", addr);
// Be careful: check 'super' might not be loaded!
if (b >= 2 && b >= super->s_nblocks)
panic("bcache_ipc: block %d out of file system bounds", b);
do {
ipc_send(ENVID_BUFCACHE, MAKE_BCREQ(b, reqtype), 0, 0);
r = ipc_recv(0, (void *) (FSMAP + b * PGSIZE), 0);
} while (r == -E_AGAIN);
return r;
}
static void
virtio_net_getstat(message *m)
{
int r;
message reply;
reply.m_type = DL_STAT_REPLY;
r = sys_safecopyto(m->m_source, m->m_net_netdrv_dl_getstat_s.grant, 0,
(vir_bytes)&virtio_net_stats,
sizeof(virtio_net_stats));
if (r != OK)
panic("%s: copy to %d failed (%d)", name, m->m_source, r);
if ((r = ipc_send(m->m_source, &reply)) != OK)
panic("%s: ipc_send to %d failed (%d)", name, m->m_source, r);
}
