int CityLamp::SendDataToLampbyID(u_short lampid, char* buf, int data_len)
{
int data_sent = 0;
//查找map中是否存在与lampid对应的sock和mutex
map<u_short, LPLampMutexSockStruct>::iterator map_it = LampID2LampMutexSockMap.find(lampid);
if (map_it != LampID2LampMutexSockMap.end()) //根据找到的Mutex对sock进行互斥写入
{
SOCKET sock = LampID2LampMutexSockMap[lampid]->sock;
Mutex *pmutex = LampID2LampMutexSockMap[lampid]->lpMutex;
{
MutexGuard guard(*pmutex);
data_sent = Sendn(sock, buf, data_len);
}
if (data_sent < data_len)
{
delete map_it->second;
{
MutexGuard guard(LampID2LampMutexSocketMapMutex);
LampID2LampMutexSockMap.erase(lampid);
}
}
}
else //不存在与lampid对应的sock和mutex
{
return -1;
}
return data_sent;
}
static int Get(char *proxyIP, int proxyport, char *URL, char *buf, int *plen) {
char buf1[MAXLENRESP];
int ris, fd, len1;
char request[MAXLENREQ];
ris=TCP_setup_connection(&fd,proxyIP,proxyport);
if(ris==0) return(0); /* errore */
/* send GET request */
sprintf(request,"GET %s\n\n",URL);
ris=Sendn(fd,request,strlen(request));
if(ris != strlen(request)) return(0);
/* receive response */
len1=0;
while(1) {
/* ris=recv(fd,buf1+len1,MAXLENRESP-len1,0); */
ris=RecvWithDelay(fd,buf1+len1,MAXLENRESP-len1);
if(ris<0) {
if(errno==EINTR) ; /* do nothing, repeat */
else return(0);
}
else if(ris==0) /* connection closed by peer */
return(0);
else { /* ris>0 */
len1+=ris;
buf1[len1]=0; /* un bel terminatore non guasta mai */
ris=check200OK(buf1,len1,buf,plen);
#ifdef DEBUG
printf("check200OK \"%s\"\nris %d\n",buf1,ris);
#endif
if(ris==0) ; /* msg incompleto, read again */
else if(ris==1) { /* msg 200 ok, gia' copiato msg in buf */
return(200);
}
else { /* -1 formato msg errato oppure NON 200 ok */
return(0);
}
}
}
return(0);
}
//?????封装2:开放socket，此函数变为给camera发送开始发送流命令，
////////////// 在加一个获取socket函数//次设计不安全，但是不在外面关闭就行了
//封装3:针对封装2，不开放socket号。封装一个socket的select函数，判断是否有数据，
//////////在封装一个获取stream的函数
int httpclient::get_stream()
{
if(!m_connectstatus)
{
return -1;
}
memset(m_sndbuf,0,CAMERASENDLEN);
sprintf(m_sndbuf, "GET /server.stream&identify_key=xxxxx HTTP/1.0\r\n\r\n");
//strcat(m_sndbuf, "Host: %s/n/r/n",);
Sendn(m_httpsock, (char*)m_sndbuf, strlen(m_sndbuf));
//get stream from camera the write to our sys
//tbd
return 0;
}
void SendDataToPCClient(char *buf, int datalength)
{
{
MutexGuard guard(PCClientListMutex);
list<PCClient*>::iterator pciter = PCClientList.begin();
while (pciter != PCClientList.end())
{
SOCKET &sock = (*pciter)->GetDataSocket();
if (sock != 0 && sock != INVALID_SOCKET)
{
if (Sendn(sock, buf, datalength) < datalength)
{
closemysocket(sock);
pciter = PCClientList.erase(pciter);
continue;
}
}
++pciter;
}
}
}
static void *DcpRecDownloadThread( void *args )
{
int ret;
int readLen = MAX_RECORD_DATA_SEND_PACKET_SIZE;
REC_DOWNLOAD_T *pRecDownload = (REC_DOWNLOAD_T *)args;
ThreadDetach( ThreadSelf() );
SVPrint( "%s start!\r\n", __FUNCTION__ );
while( 1 )
{
ret = Read( pRecDownload->fd, pRecDownload->sendPack.dataBuf, readLen );
if( ret > 0 )
{
pRecDownload->sendPack.packHead.len = ret;
pRecDownload->len = pRecDownload->sendPack.packHead.len
+ sizeof(pRecDownload->sendPack.packHead);
ret = Sendn( pRecDownload->socket, &pRecDownload->sendPack.packHead, pRecDownload->len );
if( ret != 0 )
{
break;
}
}
else
{
break;
}
}
ReleaseRecDownload( pRecDownload );
SVPrint( "%s stop!\r\n", __FUNCTION__ );
return NULL;
}
int main(int argc, char *argv[])
{
uint16_t portLBfixed;
int ris, LBfixedfd;
pthread_t th;
int primoricevuto=0;
int tipogenerazionepkt;
if(argc==1) {
printf ("uso i parametri di default \n%s\n", PARAMETRIDEFAULT );
portLBfixed = 11001;
tipogenerazionepkt=2;
}
else if(argc!=3) { printf ("necessari 2 parametri\n"); usage(); exit(1); }
else { /* leggo parametri da linea di comando */
portLBfixed = atoi(argv[1]);
tipogenerazionepkt=atoi(argv[2]);
}
if ((signal (SIGHUP, sig_close)) == SIG_ERR) { perror("signal (SIGHUP) failed: "); EExit(2); }
if ((signal (SIGINT, sig_close)) == SIG_ERR) { perror("signal (SIGINT) failed: "); EExit(2); }
if ((signal (SIGTERM, sig_close)) == SIG_ERR) { perror("signal (SIGTERM) failed: "); EExit(2); }
init_random();
ris=socketpair(AF_UNIX,SOCK_STREAM,0,fds);
if (ris < 0) { perror("socketpair fds0 failed: "); EExit(1); }
/*
ris=SetsockoptTCPNODELAY(fds[0],1); if (!ris) EExit(5);
ris=SetsockoptTCPNODELAY(fds[1],1); if (!ris) EExit(5);
*/
/* mi connetto al LBfixed */
ris=TCP_setup_connection(&LBfixedfd, "127.0.0.1", portLBfixed, 300000, 300000, 1);
if(!ris) { printf ("TCP_setup_connection() failed\n"); EExit(1); }
f=fopen("delayfixed.txt","wt");
if(f==NULL) { perror("fopen failed"); EExit(1); }
/* inizializzo il sistema di controllo dei pkt ricevuti e/o duplicati */
init_checkrecvFixed();
init_checkrecvFixedDelay();
FD_ZERO(&all);
FD_SET(LBfixedfd,&all);
maxfd=LBfixedfd;
FD_SET(fds[0],&all);
if(maxfd<fds[0]) maxfd=fds[0];
for(;;)
{
struct timeval timeout;
long int msecdelay;
do {
rdset=all;
timeout.tv_sec=10;
timeout.tv_usec=0;
ris=select(maxfd+1,&rdset,NULL,NULL,&timeout);
/* ris=select(maxfd+1,&rdset,NULL,NULL,&timeout); */
} while( (ris<0) && (errno==EINTR) );
if(ris<0) {
perror("select failed: ");
EExit(1);
}
/* se arriva qualcosa dalla connessione TCP con LBfixed, leggo!!!! */
if( FD_ISSET(LBfixedfd,&rdset) )
{
uint32_t buf[PKTSIZE], idletto; int ris;
#ifdef VICDEBUG
fprintf(stderr,"in arrivo qualcosa dalla connessione TCP del LBfixed:\n");
#endif
/* ris=recv(LBfixedfd,(char*)buf,PKTSIZE,MSG_DONTWAIT); */
/* ris=Readn(LBfixedfd,(char*)buf,PKTSIZE); */
ris=Readn(LBfixedfd,(char*)buf,sizeof(buf));
/*if(ris!=PKTSIZE) { fprintf(stderr,"recv from LBfixed failed, received %d: ", ris); EExit(9); }*/
if(ris!=sizeof(buf)) { fprintf(stderr,"recv from LBfixed failed, received %d: ", ris); EExit(9); }
idletto=buf[0];
/* printf("ricevuto pkt id %u\n",idletto); */
msecdelay=compute_delay(buf);
if( check_pkt_recv_at_Fixed(idletto) == 1 ) /* pacchetto duplicato */
{
printf("ricevuto pkt duplicato id %d delay %ld msec \n",idletto, msecdelay);
numduplicati++;
}
else
{
/* memorizzo di avere ricevuto il pkt */
set_pkt_recv_at_Fixed(idletto);
SetpktrecvFixedDelay(idletto,msecdelay);
#ifdef OUTPUT_MEDIO
printf("ricevuto pkt id %lu delay %ld msec \n",idletto, msecdelay);
#endif
if(primoricevuto==0) {
pkt_generator_parameters params;
primoricevuto=1;
idlastrecv=idletto;
/* faccio partire il pthread pkt_generator per attivare la generazione di pacchetti */
params.tipogenerazionepkt=tipogenerazionepkt;
params.fd=fds[1];
ris = pthread_create (&th, NULL, pkt_generator, (void*)¶ms );
if (ris){
printf("ERROR; return code from pthread_create() is %d\n",ris);
EExit(-1);
}
}
else if(idletto>idlastrecv) {
idlastrecv=idletto;
}
if(msecdelay>150) {
numritardi++;
printf("%d : delay msec %ld TEMPO SUPERATO\n", idletto, msecdelay);
}
else {
numok++;
printf("%d : delay msec %ld\n", idletto, msecdelay);
}
/* save_delay(f,buf); */
}
}
else
{
if( FD_ISSET(fds[0],&rdset) )
{
char ch;
/* IL BUG E' QUI: E' STATO USATO UN VETTORE DI UINT32 PER CREARE IL PACCHETTO QUANDO SI SAREBBE DOVUTO USARE UN */
/* VETTORE DI CARATTERI (char buf[PKTSIZE]) DATO CHE : */
/* sizeof(buf) = 400 , con uint32_t buf[PKTSIZE] */
/* sizeof(buf) = 100 , con char buf[PKTSIZE] */
/* ERGO LA RICEZIONE E L'INVIO DEI PACCHETTI VA FATTA CON 400 DI DIMENSIONE E NON PKTSIZE, CIOÈ 100 */
uint32_t buf[PKTSIZE];
struct timeval sent;
do {
ris=recv(fds[0],&ch,1,0);
} while( (ris<0) && (errno==EINTR) );
if(ris<0) {
perror("Appfixed - recv from scheduler failed: ");
sleep(1);
EExit(1);
}
/* spedisco i pkt */
/*memset((char*)buf,0,PKTSIZE);*/
memset((char*)buf,0,sizeof(buf));
buf[0]=idmsg;
gettimeofday(&sent,NULL);
memcpy( (char*)&(buf[1]), (char*)&sent, sizeof(struct timeval) );
/*
fprintf(stderr,"pkt %u sent %ld sec %ld usec\n", idmsg, sent.tv_sec, sent.tv_usec );
*/
/*ris=Sendn(LBfixedfd, (char*)buf, PKTSIZE );*/
ris=Sendn(LBfixedfd, (char*)buf, sizeof(buf) );
/*if(ris!=PKTSIZE) {*/
if(ris!=sizeof(buf)) {
fprintf(stderr,"Appfixed - Sendn failed ris %d TERMINO\n", ris);
sleep(1);
EExit(1);
}
#ifdef OUTPUT_MEDIO
fprintf(stderr,"pkt %u sent %dB\n", idmsg, ris);
#endif
idmsg++;
}
}
} /* fine for ;; */
return(0);
}
int main(int argc, char *argv[])
{
uint16_t portLBmobile;
int ris, LBmobilefd;
pthread_t th;
int primoricevuto=0;
printf ("uso i parametri di default \n%s\n", PARAMETRIDEFAULT );
portLBmobile = 6001;
if ((signal (SIGHUP, sig_close)) == SIG_ERR) { perror("signal (SIGHUP) failed: "); EExit(2); }
if ((signal (SIGINT, sig_close)) == SIG_ERR) { perror("signal (SIGINT) failed: "); EExit(2); }
if ((signal (SIGTERM, sig_close)) == SIG_ERR) { perror("signal (SIGTERM) failed: "); EExit(2); }
init_random();
ris=socketpair(AF_UNIX,SOCK_STREAM,0,fds);
if (ris < 0) { perror("socketpair fds0 failed: "); EExit(1); }
/* mi connetto al LBmobile */
ris=TCP_setup_connection(&LBmobilefd, "127.0.0.1", portLBmobile, 300000, 300000, 1);
if(!ris) { printf ("TCP_setup_connection() failed\n"); EExit(1); }
f=fopen("delaymobile.txt","wt");
if(f==NULL) { perror("fopen failed"); EExit(1); }
FD_ZERO(&all);
FD_SET(LBmobilefd,&all);
maxfd=LBmobilefd;
FD_SET(fds[0],&all);
if(maxfd<fds[0]) maxfd=fds[0];
ris = pthread_create (&th, NULL, scheduler, NULL );
if (ris){
printf("ERROR; return code from pthread_create() is %d\n",ris);
EExit(-1);
}
for(;;)
{
struct timeval timeout;
do {
rdset=all;
timeout.tv_sec=10;
timeout.tv_usec=0;
ris=select(maxfd+1,&rdset,NULL,NULL,&timeout);
/* ris=select(maxfd+1,&rdset,NULL,NULL,&timeout); */
} while( (ris<0) && (errno==EINTR) );
if(ris<0) {
perror("select failed: ");
EExit(1);
}
/* se arriva qualcosa dalla connessione TCP con LBmobile, leggo!!!! */
if( FD_ISSET(LBmobilefd,&rdset) )
{
uint32_t buf[PKTSIZE], idletto; int ris;
#ifdef VICDEBUG
fprintf(stderr,"in arrivo qualcosa dalla connessione TCP del LBmobile:\n");
#endif
/* ris=recv(LBmobilefd,(char*)buf,PKTSIZE,MSG_DONTWAIT); */
ris=Readn(LBmobilefd,(char*)buf,PKTSIZE);
if(ris!=PKTSIZE) { fprintf(stderr,"recv from LBmobile failed, received %d: ", ris); EExit(9); }
idletto=buf[0];
printf("ricevuto pkt id %u\n",idletto);
if(primoricevuto==0) {
primoricevuto=1;
idlastrecv=idletto;
numricevuti=1;
}
else if(idletto<=idlastrecv) {
fprintf(stderr,"ERRORE, RICEVUTO PKT FUORI ORDINE: letto %u precedente %u - TERMINO\n",idletto, idlastrecv);
EExit(999);
}
else {
if(idlastrecv+1 < idletto) {
numpersi += (idletto-(idlastrecv+1));
fprintf(stderr,"PERSO \n");
}
idlastrecv=idletto;
numricevuti++;
}
/* salvo delay pkt */
save_delay(f,buf);
}
else
{
if( FD_ISSET(fds[0],&rdset) )
{
char ch;
uint32_t buf[PKTSIZE];
struct timeval sent;
do {
ris=recv(fds[0],&ch,1,0);
} while( (ris<0) && (errno==EINTR) );
if(ris<0) {
perror("Appmobile - recv from scheduler failed: ");
sleep(1);
EExit(1);
}
/* spedisco i pkt */
memset((char*)buf,0,PKTSIZE);
buf[0]=idmsg;
gettimeofday(&sent,NULL);
memcpy( (char*)&(buf[1]), (char*)&sent, sizeof(struct timeval) );
ris=Sendn(LBmobilefd, (char*)buf, PKTSIZE );
if(ris!=PKTSIZE) {
fprintf(stderr,"Appmobile - Sendn failed ris %d TERMINO\n", ris);
sleep(1);
EExit(1);
}
fprintf(stderr,"pkt %u sent %dB\n", idmsg, ris);
idmsg++;
}
}
} /* fine for ;; */
return(0);
}
/**
* @brief Gestisce la lettura dei pacchetti UDP provenienti dal Monitor.
* @return void.
*/
void lettura_pkt_monitor(void)
{
uint32_t buf[ (65536/sizeof(uint32_t)) ];
struct sockaddr_in From;
unsigned int Fromlen;
int ris;
memset(&From,0,sizeof(From));
Fromlen=sizeof(struct sockaddr_in);
ris = recvfrom ( monitordatafd, (char*)buf, (int)65536, 0, (struct sockaddr*)&From, &Fromlen);
if (ris<0)
{
if(errno!=EINTR)
{
fprintf(stderr,"recvfrom() failed, Error: %d \"%s\"\n", errno,strerror(errno));
fprintf(stderr,"ma non ho chiuso il socket");
}
}
else
{
int ris2;
long int msecdelay;
uint32_t idletto;
uint16_t portfromfixed;
/* Salva la porta da cui arrivano i pacchetti del Fixed */
portfromfixed = ntohs(From.sin_port);
/* Se legge un ping calcola il suo delay e lo imposta 0 come id */
if(ris == SIZE_PING)
{
idletto=0;
msecdelay=compute_delay_ping(buf);
}
/* Altrimenti lo gestisce come un normale pacchetto */
else
{
idletto=buf[0];
msecdelay=compute_delay(buf);
}
/* Se sono pacchetti normali e non ping, li inoltra all'applicazione */
if(ris != SIZE_PING)
{
ris2=Sendn(appmobilefd,(char*)buf,ris);
if(ris2!=ris) { fprintf(stderr,"recv from appmobile failed, received %d: ", ris); exit(9); }
}
/* Se arriva un pacchetto in ritardo e la porta da cui arriva è la stessa da cui invia, la cambia perché LENTA */
if((msecdelay > PKT_IN_TIME) && (portfromfixed == cfgPorte[index]))
{
index=(index+1)%numporte;
}
/* Altrimenti se arriva un pacchetto in orario su una porta differente, si sincronizza su quella porta */
else if((msecdelay <= PKT_IN_TIME) && (portfromfixed != cfgPorte[index]))
{
index=trova_porta(portfromfixed, cfgPorte, index, numporte);
}
}
}
static int mysocket_writen(mysocket* const me)
{
me->len = Sendn(me->fd, me->buffer, me->len);
return 0;
}
