Re: TCP - odbieranie całej wiadomości przez recv()

2014-08-20T10:22:42+01:00

W porządku, już sprawdziłem. Tak jak podejrzewałem - informacja jest przekazywana.
Czyli to chyba faktycznie najlepszy sposób na przekazywanie większej ilości danych "w dół", do kolejnych funkcji.

Statystyki: Napisane przez Atlantis — 20 sie 2014, o 10:22

Re: TCP - odbieranie całej wiadomości przez recv()

2014-08-20T08:58:48+01:00

Odpowiedz jest prosta i w wynika z pierwszego pytania, a jesli nie widzisz jej to w 5 minut to sobie sprawdzisz.

Statystyki: Napisane przez charsz — 20 sie 2014, o 08:58

Re: TCP - odbieranie całej wiadomości przez recv()

2014-08-20T08:07:30+01:00

mokrowski napisał(a):

Przy przesyłaniu wskaźnika do funkcji, nie jest przesyłana informacja o wielkości bufora/tablicy na którą on ew. wskazuje. Typ traci informację o wielkości danych. A że wskaźnik jest na adres 32-bitowy, to i wielkość jest 4 bajty. Poza tym sizeof() to operator.

Oczywiście masz rację, przepraszam za zamieszanie.
Chciałbym przy tej okazji zapytać o jedno. Czy informacja o wielkości jest też tracona w przypadku przekazywania tablicy wchodzącej w skład struktury przez wskaźnik na tą strukturę. Czy konstrukcja sizeof(wskaźnik_na_strukture->tablica) zwróci prawidłową wartość?

Statystyki: Napisane przez Atlantis — 20 sie 2014, o 08:07

Re: TCP - odbieranie całej wiadomości przez recv()

2014-08-19T21:08:58+01:00

gordo napisał(a):

Atlantis napisał(a):

zamiast całej wiadomości (jak przedtem) recv() odbiera tylko po kilka znaków. Ktoś wie, dlaczego tak się dzieje?

rc = recv(sd, ans, sizeof(ans), MSG_WAITALL);

Zdaje się, że w tym przypadku sizeof(ans) == 4.

Hmm... Z czego to wynika? Bo wydawało mi się, że do funkcji przekazałem bufor, który miał jakieś 1000 znaków pojemności...

Statystyki: Napisane przez Atlantis — 19 sie 2014, o 21:08

Re: TCP - odbieranie całej wiadomości przez recv()

2014-08-19T20:27:50+01:00

Atlantis napisał(a):

zamiast całej wiadomości (jak przedtem) recv() odbiera tylko po kilka znaków. Ktoś wie, dlaczego tak się dzieje?

rc = recv(sd, ans, sizeof(ans), MSG_WAITALL);

Zdaje się, że w tym przypadku sizeof(ans) == 4.

Statystyki: Napisane przez gordo — 19 sie 2014, o 20:27

TCP - odbieranie całej wiadomości przez recv()

2014-08-19T18:44:16+01:00

Eksperymentując z językiem C pod Linuksem natknąłem się na kolejny problem.
Mianowicie napisałem prostą aplikację, która łączy się z serwerem MPD (daemon pełniący funkcję odtwarzacza muzycznego), parsuje dane i wyświetla informacje o muzyce na wyświetlaczu 2x16 (korzystając z biblioteki wiringPi). Cały kod jest tutaj:

[syntax=c]#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

typedef struct {
char polecenie[10];
void (* service)(char * params);
} cmd_t;

typedef struct {
char artist[255];
char title[255];
char album[255];
char genre[255];
char track[50];
char filename[500];

uint16_t songid;
uint8_t volume;
uint8_t repeat;
uint8_t random;

// enum state {STOP, PLAY, PAUSE};

uint8_t newsong:1;
uint8_t updatevolume:1;
uint8_t updateartist:1;
uint8_t updatetitle:1;
uint8_t updatefilename:1;
} player_t;

void ScrollText (char *text);
void ScrollUpdateLoop (void);
void exit_program (int signum);
void parse_mpd (char *pBuf);
void parse_title (char *params);
void parse_artist (char *params);
void parse_album (char *params);
void parse_genre (char *params);
void parse_track (char *params);
void parse_filename (char *params);
void parse_songid (char *params);
void parse_volume (char *params);

#define ILOSC_KOMEND_PODSTAWOWYCH 2

int8_t cmd_index = 0;

const char *commands[] = {
"currentsong\n",
"status\n",
"stats\n",
"play\n",
"pause\n",
"stop\n",
"previous\n",
"next\n" };

#define ANS_QTY 8

const cmd_t answers[ANS_QTY] = {
// {answer}.{wskaźnik do funkcji},
{"Title",parse_title},
{"Artist",parse_artist},
{"Album",parse_album},
{"Genre",parse_genre},
{"Track",parse_track},
{"Id",parse_songid},
{"volume",parse_volume},
{"file",parse_filename}

};

player_t player;

#define BufferLength 4000

#define SERVER "localhost"

#define SERVPORT 6600

int sd;

/* Zmienne i definicje do obsługi wyświetlacza */

#define LCD_ROWS 2
#define LCD_COLS 16
#define LCD_BITS 4//4 or 8
#define LCD_RS 7
#define LCD_E 8
#define LCD_D0 17
#define LCD_D1 18
#define LCD_D2 27
#define LCD_D3 22
#define LCD_SCROLL_BUFFER_SIZE 2000
#define SCROLL_UPDATE_INTERVAL 500

int handle;
char * beg_wsk;
char * lcd_wsk;
char * text_to_scroll;
uint32_t lcd_last_update;

char lcd_scroll_buffer[LCD_SCROLL_BUFFER_SIZE];

void exit_program (int signum) {

close (sd);
printf("\nProgram terminated, exit code %i\n", signum);
lcdClear(handle);
exit (1);
}

int main(int argc, char *argv[]) {

/* Variable and structure definitions. */

int rc, length = sizeof(int);
struct sockaddr_in serveraddr;
char buffer[BufferLength];
char server[255];
char temp;
int totalcnt = 0;
struct hostent *hostp;
int comm_timer = 0;

/* Demonizacja */

/* Our process ID and Session ID */
pid_t pid, sid;

/* Fork off the parent process */
pid = fork();
if (pid < 0) {
exit(EXIT_FAILURE);
}
/* If we got a good PID, then
we can exit the parent process. */
if (pid > 0) {
exit(EXIT_SUCCESS);
}

/* Change the file mode mask */
umask(0);

/* Open any logs here */

/* Create a new SID for the child process */
sid = setsid();
if (sid < 0) {
/* Log the failure */
exit(EXIT_FAILURE);
}

/* Change the current working directory */
if ((chdir("/")) < 0) {
/* Log the failure */
exit(EXIT_FAILURE);
}

/* Close out the standard file descriptors */
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);

buffer[BufferLength-1] = '\0';
memset(&player, 0x00, sizeof(player));

player.newsong = 1;
player.updatevolume = 1;

wiringPiSetupGpio();
lcdInit (LCD_ROWS, LCD_COLS, LCD_BITS, LCD_RS, LCD_E, LCD_D0, LCD_D1, LCD_D2, LCD_D3, 0, 0, 0, 0);

signal(SIGINT, exit_program);
signal(SIGKILL, exit_program);

if ((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
perror("Client-socket() error");
exit(-1);
}
else printf("Client-socket() OK\n");

/*If the server hostname is supplied*/

if(argc > 1) {

/*Use the supplied argument*/

strncpy(server, argv[1], sizeof(server));
printf("Connecting to the MPD server at %s, port %d ...\n", server, SERVPORT);
}
else
/*Use the default server name or IP*/
strncpy(server, SERVER, sizeof(server));

memset(&serveraddr, 0x00, sizeof(struct sockaddr_in));
serveraddr.sin_family = AF_INET;
serveraddr.sin_port = htons(SERVPORT);

if ((serveraddr.sin_addr.s_addr = inet_addr(server)) == (unsigned long)INADDR_NONE) {

/* When passing the host name of the server as a */
/* parameter to this program, use the gethostbyname() */
/* function to retrieve the address of the host server. */
/***************************************************/
/* get host address */

hostp = gethostbyname(server);

if(hostp == (struct hostent *)NULL) {

printf("HOST NOT FOUND --> ");

/* h_errno is usually defined */
/* in netdb.h */

printf("h_errno = %d\n",h_errno);
printf("---This is a client program---\n");
printf("Command usage: %s \n", argv[0]);
close(sd);
exit(-1);
}

memcpy(&serveraddr.sin_addr, hostp->h_addr, sizeof(serveraddr.sin_addr));
}

/* After the socket descriptor is received, the */
/* connect() function is used to establish a */
/* connection to the server. */
/***********************************************/
/* connect() to server. */

if((rc = connect(sd, (struct sockaddr *)&serveraddr, sizeof(serveraddr))) < 0) {
perror("Client-connect() error");
close(sd);
exit(-1);
}
else printf("Connection established...\n");

/* Flushing buffer */
rc = recv(sd, buffer, (sizeof(buffer)-1), 0);

while (1) {

/*Zdarzenie obsługi transmisji, wykonywane co 300 milisekund*/

if (millis() > comm_timer + 300) {

rc = send(sd, commands[cmd_index], strlen(commands[cmd_index]), 0);

if(rc < 0) {
perror("Client-write() error");
rc = getsockopt(sd, SOL_SOCKET, SO_ERROR, &temp, &length);
if(rc == 0) {
/* Print out the asynchronously received error. */
errno = temp;
perror("SO_ERROR was");
}
close(sd);
exit(-1);
}

rc = recv(sd, buffer, (sizeof(buffer)-1), 0);

if (rc > 0) {
buffer[rc] = '\0';
parse_mpd(buffer);
}

/* Sprawdzamy czy zmieniła się piosenka, jeśli tak
trzeba będzie uaktualnić info na wyświetlaczu */
if (player.newsong) {
/*Czy uaktualniono info o tytule?*/
if (player.updatetitle && player.updateartist) {
sprintf(lcd_scroll_buffer, "%s -%s ", player.artist, player.title);
}
else if (player.updatetitle && !player.updateartist) {
sprintf(lcd_scroll_buffer, "Unknown artist -%s ", player.title);
}
else if (!player.updatetitle && player.updateartist) {
sprintf(lcd_scroll_buffer, "%s - Unknown song ", player.artist);
}
else if (player.updatefilename) {
sprintf(lcd_scroll_buffer, "file:%s ", player.filename);
}
else {
sprintf(lcd_scroll_buffer, "ERROR: No metadata for this song ");
}

ScrollText(lcd_scroll_buffer);

player.newsong = 0;
player.updateartist = 0;
player.updatetitle = 0;
player.updatefilename = 0;
}

/* Sprawdzamy czy zmieniła się glośność, jeśli tak
trzeba będzie uaktualnić info na wyświetlaczu */
if (player.updatevolume) {
lcdPosition(handle, 8, 1);
lcdPuts(handle, " ");
lcdPosition(handle, 0, 1);
lcdPrintf(handle, "Volume: %i", player.volume);

player.updatevolume = 0;
}

if (cmd_index < ILOSC_KOMEND_PODSTAWOWYCH) {
cmd_index++;
}
else {
cmd_index = 0;
}

comm_timer = millis();

}

/* Zdarzenie obsługi przewijania na wyświetlaczu */
ScrollUpdateLoop();

usleep(500000);
}

close(sd);
exit(EXIT_SUCCESS);
return 0;
}

void parse_mpd (char *pBuf) {

char *line;
char *restofbuffer;
char *cmd;
char *restofline;

int i;

line = strtok_r(pBuf, "\n", &restofbuffer);

while (line != NULL) {

cmd = strtok_r(line, ": ", &restofline);

for (i=0; i< ANS_QTY; i++) {
if (strncasecmp(cmd, answers[i].polecenie, strlen(cmd)) == 0) {
answers[i].service (restofline);
break;
}
}

line = strtok_r(NULL, "\n", &restofbuffer);

}

}

void ScrollText (char *text) {

text_to_scroll = beg_wsk = lcd_wsk = text;

}

void ScrollUpdateLoop (void) {
uint8_t i;
if (millis() > (lcd_last_update + SCROLL_UPDATE_INTERVAL)) {
lcd_last_update = millis();
lcd_wsk = beg_wsk;
lcdPosition(handle, 0, 0);
for (i=0; i < LCD_COLS; i++) {
lcdPutchar(handle, *lcd_wsk);
lcd_wsk++;
if (!(*lcd_wsk)) lcd_wsk = text_to_scroll;
}
beg_wsk++;
if (!(*beg_wsk)) beg_wsk = text_to_scroll;
}
}

void parse_title (char *params) {
if (strncasecmp (params, player.title, strlen(params)) != 0) {
player.updatetitle = 1;
strncpy(player.title, params, sizeof(player.title));
}
}

void parse_artist (char *params) {
if (strncasecmp(params, player.artist, strlen(params)) != 0) {
player.updateartist = 1;
strncpy(player.artist, params, sizeof(player.artist));
}
}

void parse_album (char *params) {
strncpy(player.album, params, sizeof(player.album));
}

void parse_genre (char *params) {
strncpy(player.genre, params, sizeof(player.genre));
}

void parse_track (char *params) {
strncpy(player.track, params, sizeof(player.track));
}

void parse_filename (char *params) {
if (strncasecmp(params, player.filename, strlen(params)) != 0) {
player.updatefilename = 1;
strncpy(player.filename, params, sizeof(player.filename));
}
}

void parse_songid (char *params) {

uint16_t id = atoi(params);

if (id != player.songid) {
player.newsong = 1;
player.songid = id;
}
}

void parse_volume (char *params) {

uint8_t vol = atoi(params);
if ((vol >= 0) && (vol <= 100)) {
if (vol != player.volume) {
player.updatevolume = 1;
player.volume = vol;
}
}
}[/syntax]

Właściwie funkcje parsujące i wyświetlające są nieważne. Najważniejsze jest to, co dzieje się na początku funkcji main() oraz w jej pętli głównej. Szczególnie ważny jest tutaj fakt, że funkcja recv() pobiera do bufora komplet danych odsyłanych przez serwer..

Dzisiaj postanowiłem trochę upiększyć kod, wydzielając funkcje odpowiedzialne za łączność z MPD do osobnej biblioteki. Tak oto powstały dwa pliki:

mpdcl.h
[syntax=c]#ifndef MPDCL_H
#define MPDCL_H

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

/* ERROR CODES */
#define _ERR_SOCKET -1
#define _ERR_HOST_NOT_FOUND -2
#define _ERR_CONNECT -3
#define _ERR_SEND -4
#define _ERR_RECV -5

typedef struct {
char artist[255];
char title[255];
char album[255];
char genre[255];
char track[50];
char filename[500];

uint16_t songid;
uint8_t volume;
uint8_t repeat;
uint8_t random;

// enum state {STOP, PLAY, PAUSE};

uint8_t newsong:1;
uint8_t updatevolume:1;
uint8_t updateartist:1;
uint8_t updatetitle:1;
uint8_t updatefilename:1;
} player_t;

typedef struct {
char name[10];
void (* service)(player_t *player, char * params);
} ans_t;

int mpd_connect (const char *address, const int port);
int mpd_send_cmd (const char *cmd, char *ans);
void mpd_disconnect (void);
int mpd_read_player_status (player_t *player);
void mpd_parse_player_status (player_t *player, char *pBuf);
void mpd_parse_title (player_t *player, char * params);
void mpd_parse_artist (player_t *player, char * params);
void mpd_parse_album (player_t *player, char * params);
void mpd_parse_genre (player_t *player, char * params);
void mpd_parse_track (player_t *player, char * params);
void mpd_parse_filename (player_t *player, char * params);
void mpd_parse_songid (player_t *player, char * params);
void mpd_parse_volume (player_t *player, char * params);

#endif[/syntax]

mpdcl.c
[syntax=c]#include "mpdcl.h"

#define CMD_QTY 3

const char *commands[] = {
"currentsong\n",
"status\n",
"stats\n"};

#define ANS_QTY 8

const ans_t answers[ANS_QTY] = {
// {answer}.{wskaźnik do funkcji},
{"Title",mpd_parse_title},
{"Artist",mpd_parse_artist},
{"Album",mpd_parse_album},
{"Genre",mpd_parse_genre},
{"Track",mpd_parse_track},
{"Id",mpd_parse_songid},
{"volume",mpd_parse_volume},
{"file",mpd_parse_filename}

};

int sd;
struct sockaddr_in serveraddr;
struct hostent *hostp;

int mpd_connect (const char *address, const int port) {

if ((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
return _ERR_SOCKET;
}

memset(&serveraddr, 0x00, sizeof(struct sockaddr_in));
serveraddr.sin_family = AF_INET;
serveraddr.sin_port = htons(port);

if ((serveraddr.sin_addr.s_addr = inet_addr(address)) == (unsigned long)INADDR_NONE) {

hostp = gethostbyname(address);

if(hostp == (struct hostent *)NULL) {
close(sd);
return _ERR_HOST_NOT_FOUND;
}

memcpy(&serveraddr.sin_addr, hostp->h_addr, sizeof(serveraddr.sin_addr));
}

if((connect(sd, (struct sockaddr *)&serveraddr, sizeof(serveraddr))) < 0) {
close(sd);
return _ERR_CONNECT;
}

}

int mpd_send_cmd (const char *cmd, char *ans) {

int rc;

rc = send(sd, cmd, strlen(cmd), MSG_WAITALL);
if(rc < 0) {
close(sd);
return _ERR_SEND;
}

rc = recv(sd, ans, sizeof(ans), MSG_WAITALL);
if (rc > 0) {
ans[rc] = '\0';
}
else {
close(sd);
return _ERR_RECV;
}

return 0;

}

void mpd_disconnect (void) {

close(sd);

}

int mpd_read_player_status (player_t *player) {

char buffer[1000];
int i, rc;

memset(buffer, 0x00, sizeof(buffer));

for (i=0; irc = mpd_send_cmd(commands[i], buffer);
if (rc < 0) {
return rc;
}
else {
mpd_parse_player_status(player, buffer);
}
}

return 0;

}

void mpd_parse_player_status (player_t *player, char *pBuf) {

char *line;
char *restofbuffer;
char *cmd;
char *restofline;

int i;

line = strtok_r(pBuf, "\n", &restofbuffer);

while (line != NULL) {

cmd = strtok_r(line, ": ", &restofline);

for (i=0; i< ANS_QTY; i++) {
if (strncasecmp(cmd, answers[i].name, strlen(cmd)) == 0) {
answers[i].service (player, restofline);
break;
}
}

line = strtok_r(NULL, "\n", &restofbuffer);

}

}

void mpd_parse_title (player_t *player, char * params) {
if (strncasecmp (params, player->title, strlen(params)) != 0) {
player->updatetitle = 1;
strncpy(player->title, params, sizeof(player->title));
}
}

void mpd_parse_artist (player_t *player, char * params) {
if (strncasecmp(params, player->artist, strlen(params)) != 0) {
player->updateartist = 1;
strncpy(player->artist, params, sizeof(player->artist));
}
}

void mpd_parse_album (player_t *player, char * params) {
strncpy(player->album, params, sizeof(player->album));
}

void mpd_parse_genre (player_t *player, char * params) {
strncpy(player->genre, params, sizeof(player->genre));
}

void mpd_parse_track (player_t *player, char * params) {
strncpy(player->track, params, sizeof(player->track));
}

void mpd_parse_filename (player_t *player, char * params) {
if (strncasecmp(params, player->filename, strlen(params)) != 0) {
player->updatefilename = 1;
strncpy(player->filename, params, sizeof(player->filename));
}
}

void mpd_parse_songid (player_t *player, char * params) {

uint16_t id = atoi(params);

if (id != player->songid) {
player->newsong = 1;
player->songid = id;
}
}

void mpd_parse_volume (player_t *player, char * params) {

uint8_t vol = atoi(params);
if ((vol >= 0) && (vol <= 100)) {
if (vol != player->volume) {
player->updatevolume = 1;
player->volume = vol;
}
}
}[/syntax]

No i jeszcze plik z głównym kodem programu:

[syntax=c]#include
#include
#include
#include
#include
#include
#include

#include "mpdcl.h"

/* Zmienne i definicje do obsługi wyświetlacza */

#define LCD_ROWS 2
#define LCD_COLS 16
#define LCD_BITS 4//4 or 8
#define LCD_RS 7
#define LCD_E 8
#define LCD_D0 17
#define LCD_D1 18
#define LCD_D2 27
#define LCD_D3 22
#define LCD_SCROLL_BUFFER_SIZE 2000
#define SCROLL_UPDATE_INTERVAL 500

int handle;
char * beg_wsk;
char * lcd_wsk;
char * text_to_scroll;
uint32_t lcd_last_update;

char lcd_scroll_buffer[LCD_SCROLL_BUFFER_SIZE];

void ScrollText (char *text);
void ScrollUpdateLoop (void);

void exit_program (int signum) {

mpd_disconnect();
lcdClear(handle);
exit (1);
}

int main(int argc, char *argv[]) {

/* Demonizacja */
/*
pid_t pid, sid;

pid = fork();
if (pid < 0) {
exit(EXIT_FAILURE);
}

if (pid > 0) {
exit(EXIT_SUCCESS);
}

umask(0);

sid = setsid();
if (sid < 0) {
exit(EXIT_FAILURE);
}

if ((chdir("/")) < 0) {
exit(EXIT_FAILURE);
}

close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
*/

player_t player;

int comm_timer = 0;
int rc;

char buffer[2000];
memset(buffer, 0x00, sizeof(buffer));

memset(&player, 0x00, sizeof(player));
player.newsong = 1;
player.updateartist = 1;
player.updatetitle = 1;
player.updatefilename = 1;

wiringPiSetupGpio();
lcdInit (LCD_ROWS, LCD_COLS, LCD_BITS, LCD_RS, LCD_E, LCD_D0, LCD_D1, LCD_D2, LCD_D3, 0, 0, 0, 0);

signal(SIGINT, exit_program);
signal(SIGKILL, exit_program);

mpd_connect("localhost", 6600);

while (1) {

/*Zdarzenie obsługi transmisji, wykonywane co 300 milisekund*/

if (millis() > comm_timer + 300) {

rc = mpd_read_player_status(&player);
printf("Error code of mpr_read_status() function was: %i\n", rc);

printf("Artist: %s\nTitle: %s\nAlbum: %s\nFilename: %s\nVolume: %i\n", player.artist, player.title, player.album, player.filename, player.volume);
mpd_send_cmd("currentsong\n", buffer);
printf("Reply for currentsong: %s\n", buffer);

/* Sprawdzamy czy zmieniła się piosenka, jeśli tak
trzeba będzie uaktualnić info na wyświetlaczu */
if (player.newsong) {
/*Czy uaktualniono info o tytule?*/
if (player.updatetitle && player.updateartist) {
//sprintf(lcd_scroll_buffer, "%s -%s ", player.artist, player.title);
}
else if (player.updatetitle && !player.updateartist) {
sprintf(lcd_scroll_buffer, "Unknown artist -%s ", player.title);
}
else if (!player.updatetitle && player.updateartist) {
sprintf(lcd_scroll_buffer, "%s - Unknown song ", player.artist);
}
else if (player.updatefilename) {
sprintf(lcd_scroll_buffer, "file:%s ", player.filename);
}
else {
sprintf(lcd_scroll_buffer, "ERROR: No metadata for this song ");
}

ScrollText(lcd_scroll_buffer);

player.newsong = 0;
player.updateartist = 0;
player.updatetitle = 0;
player.updatefilename = 0;
}

/* Sprawdzamy czy zmieniła się glośność, jeśli tak
trzeba będzie uaktualnić info na wyświetlaczu */
if (player.updatevolume) {
lcdPosition(handle, 8, 1);
lcdPuts(handle, " ");
lcdPosition(handle, 0, 1);
lcdPrintf(handle, "Volume: %i", player.volume);

player.updatevolume = 0;
}

comm_timer = millis();

}

/* Zdarzenie obsługi przewijania na wyświetlaczu */
ScrollUpdateLoop();

usleep(500000);
}

mpd_disconnect();
exit(EXIT_SUCCESS);
return 0;
}

void ScrollText (char *text) {

text_to_scroll = beg_wsk = lcd_wsk = text;

}

void ScrollUpdateLoop (void) {
uint8_t i;
if (millis() > (lcd_last_update + SCROLL_UPDATE_INTERVAL)) {
lcd_last_update = millis();
lcd_wsk = beg_wsk;
lcdPosition(handle, 0, 0);
for (i=0; i < LCD_COLS; i++) {
lcdPutchar(handle, *lcd_wsk);
lcd_wsk++;
if (!(*lcd_wsk)) lcd_wsk = text_to_scroll;
}
beg_wsk++;
if (!(*beg_wsk)) beg_wsk = text_to_scroll;
}
}[/syntax]

Ta wersja programu nie chce działać jak należy. Po godzinie zabawy udało mi się znaleźć przycyznę - zamiast całej wiadomości (jak przedtem) recv() odbiera tylko po kilka znaków. Ktoś wie, dlaczego tak się dzieje? Ustawienie flag MSG_WAITALL w niczym nie pomaga. Można by pewnie próbować odbierać poszczególne fragmenty w pętli, łącząc je potem, zupełnie jak na AVR-ach. Jednak przede wszystkim interesuje mnie dlaczego kod przestał działać. Przecież nadając komunikat za pomocą TCP wysyłam również iformację o jego długości, więc druga strona powinna wiedzieć, czego się spodziewać. Przecież przedtem działało jak należy... Coś się mogło "wyłączyć"?

Statystyki: Napisane przez Atlantis — 19 sie 2014, o 18:44

ATNEL tech-forum

Re: TCP - odbieranie całej wiadomości przez recv()

Re: TCP - odbieranie całej wiadomości przez recv()

Re: TCP - odbieranie całej wiadomości przez recv()

Re: TCP - odbieranie całej wiadomości przez recv()

Re: TCP - odbieranie całej wiadomości przez recv()

TCP - odbieranie całej wiadomości przez recv()