codice:
ssize_t netRecvEvent(Octet *buf, TimeInternal *time, NetPath *netPath)
{
ssize_t ret;
struct msghdr msg;
struct iovec vec[1];
struct sockaddr_in from_addr; //struttura che specifica the client's address
union {
struct cmsghdr cm; //struttura che viene utilizzata per ridurre al minimo il numero di parametri
char control[CMSG_SPACE(sizeof(struct timeval))];
} cmsg_un;
struct cmsghdr *cmsg;
struct timeval *tv;
RT_TASK *lxrtnettsk; //
vec[0].iov_base = buf;
vec[0].iov_len = PACKET_SIZE;
memset(&msg, 0, sizeof(msg));
memset(&from_addr, 0, sizeof(from_addr));
memset(buf, 0, PACKET_SIZE);
memset(&cmsg_un, 0, sizeof(cmsg_un));
msg.msg_name = (caddr_t)&from_addr;
msg.msg_namelen = sizeof(from_addr);
msg.msg_iov = vec;
msg.msg_iovlen = 1;
msg.msg_control = cmsg_un.control;
msg.msg_controllen = sizeof(cmsg_un.control);
msg.msg_flags = 0;
/* Initialize a real time buddy. */
lxrtnettsk = rt_task_init(4900, 1, 0, 0);
if (NULL == lxrtnettsk) {
rt_dev_close(netPath->eventSock);
printf("CANNOT INIT MASTER TASK\n");
exit(1);
}
/* Switch over to hard realtime mode. */
rt_make_hard_real_time();
// ret = rt_dev_recv(netPath->eventSock, msg, sizeof(msg), 0);
// ret = rt_dev_recv(netPath->eventSock, msg.msg_name, sizeof(&msg), 0);
ret = rt_dev_recv(netPath->eventSock, msg.msg_name, sizeof(&msg), 0);
/* Switch over to soft realtime mode. */
rt_make_soft_real_time(); // aggiunto !!
/* Delete realtime buddy. */
rt_task_delete(lxrtnettsk); //aggiunto !!
// ret = recvmsg(netPath->eventSock, &msg, MSG_DONTWAIT); // funzione che deve ricevere un messaggio da una modalità di connessione tipicamente da un socket
if(ret <= 0)
{
if(errno == EAGAIN || errno == EINTR) // files libreria standard d C che contiene definizioni di macro per la gestione delle situazioni di errori
return 0;
return ret;
}
if(msg.msg_flags&MSG_TRUNC)
{
ERROR("received truncated message\n");
return 0;
}
/* get time stamp of packet */
if(!time)
{
ERROR("null receive time stamp argument\n");
return 0;
}
if(msg.msg_flags&MSG_CTRUNC)
{
ERROR("received truncated ancillary data\n");
return 0;
}
if(msg.msg_controllen < sizeof(cmsg_un.control))
{
ERROR("received short ancillary data (%d/%d)\n",
msg.msg_controllen, (int)sizeof(cmsg_un.control));
return 0;
}
tv = 0;
for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL; cmsg = CMSG_NXTHDR(&msg, cmsg))
{
if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_TIMESTAMP)
tv = (struct timeval *)CMSG_DATA(cmsg);
}
if(tv)
{
time->seconds = tv->tv_sec;
time->nanoseconds = tv->tv_usec*1000;
DBGV("kernel recv time stamp %us %dns\n", time->seconds, time->nanoseconds);
}
else
{
/* do not try to get by with recording the time here, better to fail
because the time recorded could be well after the message receive,
which would put a big spike in the offset signal sent to the clock servo */
DBG("no recieve time stamp\n");
return 0;
}
return ret;
}
ssize_t netRecvGeneral(Octet *buf, NetPath *netPath)
{
RT_TASK *lxrtnettsk; //
ssize_t ret; //ssize_t , è un tipo di dato per rappresentare le dimenzione dei blocchi, che possono essere letti o scritti in una sola operazione
//struct sockaddr_in addr; // struttura per impostare gli indirizzi
//socklen_t addr_len = sizeof(struct sockaddr_in); // socklen_t--> richiamo di una applicazione UDP
//socket = punto di contatto tra un processo e una risorsa gestita
//receive from, è una funzione di input/output di un socket
/* Initialize a real time buddy. */
lxrtnettsk = rt_task_init(4900, 1, 0, 0);
if (NULL == lxrtnettsk) {
rt_dev_close(netPath->eventSock);
printf("CANNOT INIT MASTER TASK\n");
exit(1);
}
/* Switch over to hard realtime mode. */
rt_make_hard_real_time();
ret = rt_dev_recv(netPath->generalSock, buf, sizeof(buf), 0); //
/* Switch over to soft realtime mode. */
rt_make_soft_real_time(); // aggiunto !!
/* Delete realtime buddy. */
rt_task_delete(lxrtnettsk); //aggiunto !!
// ret = recvfrom(netPath->generalSock, buf, PACKET_SIZE, MSG_DONTWAIT, (struct sockaddr *)&addr, &addr_len);
if(ret <= 0)
{
if(errno == EAGAIN || errno == EINTR) //erro rappresenta la libreria standard del C che contiene definizioni di macro per la gestione delle situazioni di errore.
return 0;
return ret;
}
return ret;
}
ssize_t netSendEvent(Octet *buf, UInteger16 length, NetPath *netPath)
{
ssize_t ret;
struct sockaddr_in addr; // struttura per impostare gli indirizzi
addr.sin_family = AF_INET;
addr.sin_port = htons(PTP_EVENT_PORT);
addr.sin_addr.s_addr = netPath->multicastAddr;
RT_TASK *lxrtnettsk; //
/* Initialize a real time buddy. */
lxrtnettsk = rt_task_init(4900, 1, 0, 0);
if (NULL == lxrtnettsk) {
rt_dev_close(netPath->eventSock);
printf("CANNOT INIT MASTER TASK\n");
exit(1);
}
/* Switch over to hard realtime mode. */
rt_make_hard_real_time();
ret = rt_dev_send(netPath->eventSock, buf, length, 0);
// ret = sendto(netPath->eventSock, buf, length, 0, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)); // sendto, è un dato di Imput/Output, dei socket
if(ret <= 0)
DBG("error sending multi-cast event message\n");
if(netPath->unicastAddr) //nethPath, consente di lavorare con file di vari percorssi, valori di stringa utilizzati per eseguire la totalità delle operazioni
{
addr.sin_addr.s_addr = netPath->unicastAddr;
// ret = sendto(netPath->eventSock, buf, length, 0, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)); ////ssize_t , è un tipo di dato per rappresentare le dimenzione dei blocchi, che possono essere letti o scritti in una sola operazione
ret = rt_dev_send(netPath->eventSock, buf, length, 0);
if(ret <= 0)
DBG("error sending uni-cast event message\n"); //DBG , sono dei tipi di flies, in formato Portable Executable, conteneti informazioni di debug in formato codeView
}
/* Switch over to soft realtime mode. */
rt_make_soft_real_time(); // aggiunto !!
/* Delete realtime buddy. */
rt_task_delete(lxrtnettsk); //aggiunto !!
return ret;
}
ssize_t netSendGeneral(Octet *buf, UInteger16 length, NetPath *netPath)
{
ssize_t ret;
struct sockaddr_in addr; // struttura per impostare gli indirizzi
//'netRecvEvent';
addr.sin_family = AF_INET;
addr.sin_port = htons(PTP_GENERAL_PORT);
addr.sin_addr.s_addr = netPath->multicastAddr;
RT_TASK *lxrtnettsk; //
/* Initialize a real time buddy. */
lxrtnettsk = rt_task_init(4900, 1, 0, 0);
if (NULL == lxrtnettsk) {
rt_dev_close(netPath->eventSock);
printf("CANNOT INIT MASTER TASK\n");
exit(1);
}
/* Switch over to hard realtime mode. */
rt_make_hard_real_time();
// ret = sendto(netPath->generalSock, buf, length, 0, (struct sockaddr *)&addr, sizeof(struct sockaddr_in));
ret = rt_dev_send(netPath->generalSock, buf, length, 0);
if(ret <= 0)
DBG("error sending multi-cast general message\n");
if(netPath->unicastAddr)
{
addr.sin_addr.s_addr = netPath->unicastAddr;
// ret = sendto(netPath->eventSock, buf, length, 0, (struct sockaddr *)&addr, sizeof(struct sockaddr_in));
ret = rt_dev_send(netPath->eventSock, buf, length, 0);
if(ret <= 0)
DBG("error sending uni-cast general message\n");
}
/* Switch over to soft realtime mode. */
rt_make_soft_real_time(); // aggiunto !!
/* Delete realtime buddy. */
rt_task_delete(lxrtnettsk); //aggiunto !!
return ret;
}
GRAZIE MILLE PER L'AIUTO!!
Rispondi quotando