int main()
{
int sockfd, n = 0, tfd;
struct sockaddr_un cliaddr;
struct msg_rec *msg;
char *c = "c";
char vm[5], hostname[10], buffer[16], data[50];
struct hostent *ent;
char buff[22];
gethostname(hostname, sizeof(hostname));
printdebuginfo("My hostname: %s\n", hostname);
sockfd = Socket(AF_LOCAL, SOCK_DGRAM, 0);
bzero(&cliaddr, sizeof(cliaddr));
cliaddr.sun_family = AF_LOCAL;
strcpy(cliaddr.sun_path,"/tmp/myTmpFile-XXXXXX");
tfd = mkstemp(cliaddr.sun_path);
unlink(cliaddr.sun_path);
//sun_path = cliaddr.sun_path;
Bind(sockfd, (SA *) &cliaddr, sizeof(cliaddr));
printdebuginfo("\n%s\n", cliaddr.sun_path);
//signal(SIGINT, intHandler);
while (1) {
getInput(vm);
if((ent = gethostbyname(vm)) == NULL) {
perror("gethostbyname returned NULL");
exit(1);
}
inet_ntop(PF_INET, ent->h_addr_list[0], buffer, sizeof(buffer));
printdebuginfo("%s\n", buffer);
printf("\nclient at node %s sending request to server at %s\n", hostname, vm);
n = msg_send(sockfd, buffer, SERVER_PORT, c, 0);
msg = msg_recv(sockfd, 1);
if(msg == NULL) {
printf("client at node %s: timeout on response from %s\n", hostname, vm);
n = msg_send(sockfd, buffer, SERVER_PORT, c, 1);
msg = msg_recv(sockfd, 1);
if(msg == NULL) {
printf("client at node %s: timeout on response from %s\n", hostname, vm);
continue;
}
}
printf("client at node %s: received from %s <%s>\n", hostname, vm, msg->msg);
free(msg);
}
close(sockfd);
exit(0);
}
int
do_repeated_task(int server_sock_fd)
{
char buffer[200];
peerinfo_t *peerincontact = NULL;
char src_ip[MAX_IP_LEN];
int src_port;
time_t ticks;
char my_hostname[MAXLINE];
gethostname(my_hostname, sizeof(my_hostname));
while (42) {
memset(buffer, 0, sizeof(buffer));
if (msg_recv(server_sock_fd, buffer, src_ip, &src_port) < 0) {
fprintf (stderr, "Failed to receive message: %s\n", strerror(errno));
return -1;
}
ticks = time(NULL);
memset(buffer, 0, sizeof(buffer));
snprintf(buffer, sizeof(buffer), "%.24s\r\n", ctime(&ticks));
//printf("I will send %s\n", buffer);
fprintf (stdout, "TRACE: Server at node %s responding to request from %s\n",
my_hostname, src_ip);
if (msg_send(server_sock_fd, src_ip, src_port, buffer, 0) < 0) {
fprintf (stderr, "Failed to send message: %s\n", strerror(errno));
return -1;
}
}
}
int
cred_recv(int sock, struct cmsgcred *cred)
{
unsigned char credbuf[CMSG_SPACE(sizeof(struct cmsgcred))];
struct msghdr msg;
struct cmsghdr *cmsg;
struct iovec iov;
uint8_t dummy;
bzero(credbuf, sizeof(credbuf));
bzero(&msg, sizeof(msg));
bzero(&iov, sizeof(iov));
iov.iov_base = &dummy;
iov.iov_len = sizeof(dummy);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = credbuf;
msg.msg_controllen = sizeof(credbuf);
if (msg_recv(sock, &msg) == -1)
return (-1);
cmsg = CMSG_FIRSTHDR(&msg);
if (cmsg == NULL ||
cmsg->cmsg_len != CMSG_LEN(sizeof(struct cmsgcred)) ||
cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_CREDS) {
errno = EINVAL;
return (-1);
}
bcopy(CMSG_DATA(cmsg), cred, sizeof(*cred));
return (0);
}
void MainDlg::OnRecvMsg()
{
char buff[1024] = {0};
uint32_t user_id;
struct msg_packet msg;
while(1)
{
msg_recv(&msg);
user_id = process_msg(&msg);
switch (GET_MODE(msg.command))
{
case IPMSG_SENDMSG:
break;
case IPMSG_ANSENTRY:
case IPMSG_BR_ENTRY:
OnFriendOnline(user_find(user_id));
break;
case IPMSG_BR_EXIT:
break;
}
}
}
int stlink2_swim_read_range(programmer_t *pgm, stm8_device_t *device, unsigned char *buffer, unsigned int start, unsigned int length) {
stlink2_init_session(pgm);
int i;
for(i = 0; i < length; i += STLK_READ_BUFFER_SIZE) {
// Determining current block start & size (relative to 0x8000)
int block_start = start + i;
int block_size = length - i;
if(block_size > STLK_READ_BUFFER_SIZE) {
block_size = STLK_READ_BUFFER_SIZE;
}
// Sending USB packet
stlink2_cmd(pgm, 0xf40b, 6,
HI(block_size), LO(block_size),
0x00, 0x00,
HI(block_start), LO(block_start));
TRY(128, (stlink2_get_status(pgm) & 0xffff) == 0);
// Seems like we've got some bytes from stlink, downloading them
stlink2_cmd(pgm, 0xf40c, 0);
msg_recv(pgm, &(buffer[i]), block_size);
}
return(length);
}
int main()
{
//printf("this is msg_ser!\n");
int msg_id = msg_create();//ser
if(msg_id < 0)
return 1;
printf("ID:> %d\t\n\n",msg_id);
char buf[G_SIZE];
while(1)
{
buf[G_SIZE-1]='\0';
int ret =msg_recv(msg_id,buf,\
sizeof(buf)-1,DATA_TYPE_CLI);
printf("cli:>%s\n",buf);
fflush(stdout);
memset(buf,'\0',sizeof(buf));
printf("Please Input:\n ");
char *ar = fgets(buf,sizeof(buf)-1,stdin);
if(strncasecmp(ar,"quit",4) == 0)
break;
ret = msg_send(msg_id,buf,DATA_TYPE_SER);
}
msg_destroy(msg_id);
// sleep(10);
// int ret = msg_destroy(msg_id);
// printf("destroy code is:> %d\n",ret);
return 0;
}
void minipro_read_block(minipro_handle_t *handle, unsigned int type, unsigned int addr, unsigned char *buf, unsigned int len) {
msg_init(msg, type, handle->device, handle->icsp);
format_int(&(msg[2]), len, 2, MP_LITTLE_ENDIAN);
format_int(&(msg[4]), addr, 3, MP_LITTLE_ENDIAN);
msg_send(handle, msg, 18);
msg_recv(handle, buf, len);
}
void recv_func(void* arg)
{
uint32_t user_id;
struct msg_packet msg;
while(1)
{
msg_recv(&msg);
user_id = process_msg(&msg);
switch (GET_MODE(msg.command))
{
case IPMSG_SENDMSG:
console_clear_line(-1);
shell_recv_msg(user_id);
printf("%s", buff);
break;
case IPMSG_ANSENTRY:
case IPMSG_BR_ENTRY:
shell_user_entry(user_id);
case IPMSG_BR_EXIT:
console_clear_line(-1);
shell_user_exit(user_id, msg.msg);
printf("%s", buff);
break;
}
}
}
static struct ks_res *
process_request(struct ks_req *req)
{
struct message msg;
struct ks_res *res;
msg.req = *req;
msg.from = getpid();
switch(req->req) {
case DELETE:
case GET:
case INIT:
case INSERT:
case RESET:
break;
default:
log_err("unknown request");
return NULL;
}
if (msg_send(blob, &msg, sizeof(msg)) == -1)
fatal("blob died");
/*
* todo: -1 is returned
*/
if ((res = malloc(sizeof(struct ks_res))) == NULL)
fatal("malloc failed");
memset(res, 0, sizeof(*res));
msg_recv(blob, (void **)&res, sizeof(struct ks_res));
return res;
}
void minipro_get_system_info(minipro_handle_t *handle, minipro_system_info_t *out) {
unsigned char buf[40];
memset(msg, 0x0, 5);
msg[0] = MP_GET_SYSTEM_INFO;
msg_send(handle, msg, 5);
msg_recv(handle, buf, 40);
// Protocol version
switch(out->protocol = buf[1]) {
case 1:
case 2:
break;
default:
ERROR("Protocol version error");
}
// Model
switch(out->protocol = buf[6]) {
case MP_TL866A:
out->model_str = "TL866A";
break;
case MP_TL866CS:
out->model_str = "TL866CS";
break;
default:
ERROR("Unknown device");
}
// Firmware
out->firmware = load_int(&(buf[4]), 2, MP_LITTLE_ENDIAN);
if(out->firmware < MP_FIRMWARE_VERSION) {
fprintf(stderr, "Warning: firmware is too old\n");
}
sprintf(out->firmware_str, "%d.%d.%d", buf[39], buf[4], buf[5]);
}
void
mtd_thread_t::run ()
{
mtd_status_t rc;
GIANT_LOCK();
bool ok = init_phase0() && init();
GIANT_UNLOCK();
if (!ok) {
TWARN ("thread could not initialize");
msg_send (MTD_SHUTDOWN);
delete this;
return;
}
become_ready ();
do {
GIANT_LOCK();
take_svccb ();
GIANT_UNLOCK();
rc = msg_recv ();
} while (rc == MTD_CONTINUE);
cell->status = MTD_SHUTDOWN;
msg_send (MTD_SHUTDOWN);
return;
}
void minipro_write_fuses(minipro_handle_t *handle, unsigned int type, unsigned int length, unsigned char *buf) {
// Perform actual writing
switch(type & 0xf0) {
case 0x10:
msg_init(msg, type + 1, handle->device, handle->icsp);
msg[2] = (length==4)?0x02:0x01; // 2 fuse PICs have len=8
msg[4] = 0xc8;
msg[5] = 0x0f;
msg[6] = 0x00;
memcpy(&(msg[7]), buf, length);
msg_send(handle, msg, 64);
break;
case 0x40:
msg_init(msg, type - 1, handle->device, handle->icsp);
memcpy(&(msg[7]), buf, length);
msg_send(handle, msg, 10);
break;
}
// The device waits us to get the status now
msg_init(msg, type, handle->device, handle->icsp);
msg[2]=(type==18 && length==4)?2:1; // note that PICs with 1 config word will show length==2
memcpy(&(msg[7]), buf, length);
msg_send(handle, msg, 18);
msg_recv(handle, msg, 7 + length);
if(memcmp(buf, &(msg[7]), length)) {
ERROR("Failed while writing config bytes");
}
}
int main()
{
int msg_id = msg_get();//cli
if(msg_id < 0)
return 1;
char buf[G_SIZE];
while(1)
{
memset(buf,'\0',sizeof(buf));
printf("Please Input\n: ");
fflush(stdout);
char *ar = fgets(buf,sizeof(buf)-1,stdin);
if(strncasecmp(ar,"quit",4) == 0)
break;
msg_send(msg_id,buf,DATA_TYPE_CLI);
int ret =msg_recv(msg_id,buf,\
sizeof(buf)-1,DATA_TYPE_SER);
printf("ser:>%s\n",buf);
fflush(stdout);
memset(buf,'\0',sizeof(buf));
}
// sleep(10);
// int ret = msg_destroy(msg_id);
// printf("destroy code is:> %d\n",ret);
return 0;
}
/* Model-specific ID, e.g. AVR Device ID (not longer than 4 bytes) */
int minipro_get_chip_id(minipro_handle_t *handle) {
msg_init(msg, MP_GET_CHIP_ID, handle->device, handle->icsp);
msg_send(handle, msg, 8);
msg_recv(handle, msg, 5 + handle->device->chip_id_bytes_count);
return(load_int(&(msg[2]), handle->device->chip_id_bytes_count, MP_BIG_ENDIAN));
}
int main()
{
int msg_id = msg_create(); //ser
if(msg_id < 0)
{
return 1;
}
char buf[G_SIZE];
while(1)
{
buf[G_SIZE - 1] = '\0';
int ret = msg_recv(msg_id, buf, sizeof(buf)-1, DATA_TYPE_CLI);
if(strncasecmp("quite", buf, 4) == 0)
{ break;}
printf("cli:> %s\n", buf);
printf("plase Enter:");
fflush(stdout);
memset(buf, '\0', sizeof(buf));
fgets(buf, sizeof(buf)-1, stdin);
ret = msg_send(msg_id, buf, DATA_TYPE_SER);
}
int ret = msg_destroy(msg_id);
return 0;
}
static void udp_recv_handler(const struct sa *src, struct mbuf *mb,
void *arg)
{
struct nat_hairpinning *nh = arg;
msg_recv(nh, IPPROTO_UDP, nh->us, src, mb);
}
void minipro_read_block(minipro_handle_t *handle, unsigned int type, unsigned int addr, unsigned char *buf) {
msg_init(msg, type, handle->device);
format_int(&(msg[2]), handle->device->read_buffer_size, 2, MP_LITTLE_ENDIAN);
format_int(&(msg[4]), addr, 3, MP_LITTLE_ENDIAN);
msg_send(handle, msg, 18);
msg_recv(handle, buf, handle->device->read_buffer_size);
}
void send_loop() {
printf("client at node %s sending request to server at %s\n", hostname, input);
msg_send(uds_socket.fd, dest_addr, SERVER_PORT, "time?", 0);
ntimeouts = 0;
while (1) {
FD_ZERO(&readset);
FD_SET(uds_socket.fd, &readset);
timeout.tv_sec = TIMEOUT_SECONDS;
timeout.tv_usec = 0;
nready = select(uds_socket.fd + 1, &readset, NULL, NULL, &timeout);
if (nready > 0) {
msg_recv(uds_socket.fd, recv_buffer, recv_addr, &recv_port);
printf("client at node %s received from server at %s %s\n", hostname, input, recv_buffer);
return;
} else if (nready == 0) {
printf("client at node %s timed out when sending to server %s\n", hostname, input);
if (ntimeouts == 0) {
printf("sending again and forcing rediscovery\n");
msg_send(uds_socket.fd, dest_addr, SERVER_PORT, "time?", 1);
ntimeouts++;
} else {
printf("second time out, giving up\n");
return;
}
} else if (nready == -1 && errno == EINTR) {
continue;
} else {
printf("select error\n");
}
}
}
int main() {
char buffer[1024];
struct sockaddr_un serAddr;
int sockfd;
getFullPath(filePath, SER_FILE, sizeof(filePath), FALSE);
sockfd = createAndBindUnixSocket(filePath);
hostNode = getHostVmNodeNo();
getIPByVmNode(hostIP, hostNode);
printf("Server running on VM%d (%s)\n", hostNode, hostIP);
Signal(SIGINT, sig_int);
while (1) {
char clientIP[100];
int clientPort;
time_t ticks;
msg_recv(sockfd, buffer, clientIP, &clientPort);
// Get current time and store in buffer
ticks = time(NULL);
snprintf(buffer, sizeof(buffer), "%.24s", ctime(&ticks));
printf("Server at node VM%d: responding to request from VM%d\n", hostNode, getVmNodeByIP(clientIP));
msg_send(sockfd, clientIP, clientPort, buffer, FALSE);
}
Close(sockfd);
}
/*****************************************************************************
Prototype : msg_process
Description : process msg
Input : VidEncThrEnv *envp
CommonMsg *msgBuf
Output : None
Return Value : static
Calls :
Called By :
History :
1.Date : 2012/3/8
Author : Sun
Modification : Created function
*****************************************************************************/
static Int32 msg_process(VidEncThrEnv *envp, CommonMsg *msgBuf)
{
Int32 ret;
/* recv msg */
ret = msg_recv(envp->hMsg, msgBuf, sizeof(CommonMsg));
if(ret < 0) {
ERR("img enc thr recv msg err: %s", str_err(ret));
return ret;
}
/* process msg */
MsgHeader *msgHdr = &msgBuf->header;
switch(msgHdr->cmd) {
case APPCMD_NEW_DATA:
ret = vid_enc_thr_run(envp, (ImgMsg *)msgBuf);
break;
case APPCMD_SET_VID_ENC_PARAMS:
ret = vid_enc_params_update(envp);
break;
case APPCMD_EXIT:
envp->exit = TRUE;
break;
default:
ERR("unkown cmd: 0x%X", (unsigned int)msgHdr->cmd);
ret = E_UNSUPT;
break;
}
return ret;
}
void
mtdispatch_t::chld_msg ()
{
mtd_msg_t msg;
int rc = msg_recv (fdin, &msg);
if (rc < 0) {
warn ("Bad receive message: %m\n");
return;
}
//warn << "Received message from child: " << msg << "\n"; // debug
switch (msg.status) {
case MTD_READY:
if (sdflag) shutdown ();
chld_ready (msg.tid);
break;
case MTD_REPLY:
if (sdflag) shutdown ();
chld_reply (msg.tid);
break;
case MTD_SHUTDOWN:
warn << "Lost a child!\n";
// XXX - recover?
break;
default:
warn << "Unknown message received: " << msg << "\n";
}
}
void minipro_prepare_writing(minipro_handle_t *handle) {
unsigned char buf[10];
msg_init(msg, MP_PREPARE_WRITING, handle->device, handle->icsp);
format_int(&(msg[2]), 0x03, 2, MP_LITTLE_ENDIAN);
msg[2] = handle->device->write_unlock;
msg_send(handle, msg, 15);
msg_recv(handle, buf, 10);
}
void minipro_read_fuses(minipro_handle_t *handle, unsigned int type, unsigned int length, unsigned char *buf) {
msg_init(msg, type, handle->device, handle->icsp);
msg[2]=(type==18 && length==4)?2:1; // note that PICs with 1 config word will show length==2
msg[5]=0x10;
msg_send(handle, msg, 18);
msg_recv(handle, msg, 7 + length );
memcpy(buf, &(msg[7]), length);
}
message_t* msg_recv_wait(int recipient)
{
message_t *msg;
while ((msg = msg_recv(recipient)) == NULL)
usleep(SLEEPTIME);
return msg;
}
int
fd_recv(int sock, int *fds, size_t nfds)
{
struct msghdr msg;
struct cmsghdr *cmsg;
unsigned int i;
int serrno, ret;
if (nfds == 0 || fds == NULL) {
errno = EINVAL;
return (-1);
}
bzero(&msg, sizeof(msg));
msg.msg_iov = NULL;
msg.msg_iovlen = 0;
msg.msg_controllen = nfds * CMSG_SPACE(sizeof(int));
msg.msg_control = calloc(1, msg.msg_controllen);
if (msg.msg_control == NULL)
return (-1);
ret = -1;
if (msg_recv(sock, &msg) == -1)
goto end;
for (i = 0, cmsg = CMSG_FIRSTHDR(&msg); i < nfds && cmsg != NULL;
i++, cmsg = CMSG_NXTHDR(&msg, cmsg)) {
fds[i] = msghdr_get_fd(cmsg);
if (fds[i] < 0)
break;
}
if (cmsg != NULL || i < nfds) {
int fd;
/*
* We need to close all received descriptors, even if we have
* different control message (eg. SCM_CREDS) in between.
*/
for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL;
cmsg = CMSG_NXTHDR(&msg, cmsg)) {
fd = msghdr_get_fd(cmsg);
if (fd >= 0)
close(fd);
}
errno = EINVAL;
goto end;
}
ret = 0;
end:
serrno = errno;
free(msg.msg_control);
errno = serrno;
return (ret);
}
/*************************************************************************
*
* FUNCTION
*
* mcapi_msg_recv
*
* DESCRIPTION
*
* Blocking API routine to receive a connectionless message on a
* local endpoint.
*
* INPUTS
*
* receive_endpoint The local endpoint identifer that is
* receiving the data.
* *buffer A pointer to memory that will be filled in
* with the received data.
* buffer_size The number of bytes that will fit in *buffer.
* *received_size The number of bytes received.
* *mcapi_status A pointer to memory that will be filled in
* with the status of the call.
*
* OUTPUTS
*
* None.
*
*************************************************************************/
void mcapi_msg_recv(mcapi_endpoint_t receive_endpoint, void *buffer,
size_t buffer_size, size_t *received_size,
mcapi_status_t *mcapi_status)
{
mcapi_request_t request;
/* Call the receive routine, indicating to block. */
msg_recv(receive_endpoint, buffer, buffer_size, received_size,
&request, mcapi_status, 0xffffffff);
}
int minipro_get_status(minipro_handle_t *handle) {
unsigned char buf[32];
msg_init(msg, MP_REQUEST_STATUS1_MSG2, handle->device, handle->icsp);
msg_send(handle, msg, 5);
msg_recv(handle, buf, 32);
if(buf[9] != 0) {
ERROR("Overcurrency protection");
}
return(load_int(buf, 2, MP_LITTLE_ENDIAN));
}
int main(int argc, char **argv)
{
getAllIP();
int count;
int sockfd;
struct sockaddr_un servaddr;
sockfd=Socket(AF_LOCAL, SOCK_DGRAM, 0);
unlink(SERV_WKPATH);
bzero(&servaddr, sizeof(servaddr));
servaddr.sun_family=AF_LOCAL;
strcpy(servaddr.sun_path, SERV_WKPATH);
Bind(sockfd, (SA *)&servaddr, sizeof(servaddr));
char *message=(char *)Malloc(32);
char ip_src[INET_ADDRSTRLEN];
char ip_dest[INET_ADDRSTRLEN];
unsigned short port_src;
unsigned short port_dest;
for( ; ; )
{
msg_recv(sockfd, message, ip_src, &port_src, ip_dest, &port_dest);
//printf("%s\n", ip_src);
//printf("%d\n", port_src);
//printf("%s\n", message);
struct sockaddr_un cliaddr;
bzero(&cliaddr, sizeof(cliaddr));
cliaddr.sun_family=AF_LOCAL;
strcpy(cliaddr.sun_path, ODR_PATH);
char *new_message=(char *)Malloc(32);
for(count=0;count<32;count++)
{
new_message[count]='\0';
}
time_t ticks;
ticks=time(NULL);
sprintf(new_message, "%.24s\r\n", ctime(&ticks));
msg_send(sockfd, (SA *)&cliaddr, sizeof(cliaddr), ip_dest, ip_src, port_src, new_message, 0);
printf("##SEND# server at node vm%d responding to request from vm%d.\n", getVMNum(ip_src)+1, getVMNum(ip_dest)+1);
}
unlink(SERV_WKPATH);
}
static int msg_query(struct nlmsghdr *nlh, mnl_cb_t callback, void *data)
{
unsigned int seq;
struct mnl_socket *nl;
seq = time(NULL);
nlh->nlmsg_seq = seq;
nl = msg_send(nlh);
if (!nl)
return -ENOTSUP;
return msg_recv(nl, callback, data, seq);
}
static int set_prop(struct arg_struct *arg, int nla, char *name)
{
int err;
char *bearer;
struct tipc_nl_msg msg;
struct nlattr *attrs;
struct nlattr *prop;
__u32 val;
/* Two mandatory (bearer, attribute) */
if (arg->argc < arg->loc + 2)
return -EINVAL;
bearer = arg->argv[arg->loc];
val = atoi(arg->argv[arg->loc + 1]);
msg.nl_flags = NLM_F_REQUEST;
msg.nl_cmd = TIPC_NL_BEARER_SET;
err = msg_init(&msg);
if (err)
return err;
attrs = nla_nest_start(msg.nl_msg, TIPC_NLA_BEARER);
NLA_PUT_STRING(msg.nl_msg, TIPC_NLA_BEARER_NAME, bearer);
prop = nla_nest_start(msg.nl_msg, TIPC_NLA_BEARER_PROP);
NLA_PUT_U32(msg.nl_msg, nla, val);
nla_nest_end(msg.nl_msg, prop);
nla_nest_end(msg.nl_msg, attrs);
err = msg_send(&msg);
if (err)
return err;
err = msg_recv(&msg, NULL);
if (err)
return err;
log_info("Bearer %s %s set to %u\n", bearer, name, val);
return 0;
nla_put_failure:
msg_abort(&msg);
return -ENOBUFS;
}
