// reciever uses the function
int receive_file(int sock, struct sockaddr_in *send_adr, socklen_t *send_adr_sz, char *filename, uint32_t seg_size)
{
off_t current_filesize = get_file_size(filename);
uint32_t curr_segment_num = (current_filesize % seg_size != 0) ? 1 + current_filesize / seg_size : current_filesize / seg_size;
char response[MAX_BUFFER_SIZE];
ssize_t response_len;
buffer *b;
create_buffer(&b, 1024);
do {
response_len = timer_recvfrom(sock, response, MAX_BUFFER_SIZE, 0, (struct sockaddr *)send_adr, send_adr_sz, TIMEOUT, NUM_TRY);
akh_pdu_header *pheader = (akh_pdu_header *)response;
// time-out
if(response_len == -1)
return -1;
else if(pheader->msg_type == SS) {
printf("SS seq_num => %d\n", pheader->seq_num);
if(pheader->seq_num == curr_segment_num) {
write_segment(response + sizeof(akh_pdu_header), response_len - sizeof(akh_pdu_header), filename);
curr_segment_num++;
}
else {
push(b, response, response_len);
}
uint32_t temp;
do {
temp = curr_segment_num;
pop(b, response, &response_len);
pheader = (akh_pdu_header *)response;
if(pheader->seq_num == curr_segment_num) {
write_segment(response + sizeof(akh_pdu_header), response_len - sizeof(akh_pdu_header), filename);
curr_segment_num++;
}
push(b, response, response_len);
} while(pheader->seq_num == temp);
}
puts("< receive file segment >");
printf("msg_type = %x\tseq_num = %d\n", pheader->msg_type, pheader->seq_num);
} while(((akh_pdu_header *)response)->msg_type == SS);
return ((akh_pdu_header *)response)->msg_type;
}
/**
* Writes a number to the LED display
* Can handle up to 3-digit decimal numbers (<=250)
**/
void display(unsigned int value) {
unsigned char i;
// Separate value to digits and print each one
for (i = 0; i < NUMBER_OF_DIGITS; i++) {
write_segment(i, get_digit(value, i));
}
}
/* Write as much as fits from buffer to the given segment on tape
* and handle retries.
* Return the number of bytes written (>= 0), or:
* -EIO write failed
* -EINTR interrupted by signal
* -ENOSPC device full
*/
int _write_segment(unsigned int segment_id, byte * buffer, int flush)
{
TRACE_FUN(5, "_write_segment");
int retry = 0;
int result;
history.used |= 2;
for (;;) {
if (segment_id > ftape_last_segment.id && !flush) {
result = -ENOSPC; /* tape full */
break;
}
result = write_segment(segment_id, buffer, flush);
if (result < 0) {
if (result == -EAGAIN) {
if (++retry > 100) {
TRACE(1, "write failed, >100 retries in segment");
result = -EIO; /* give up */
break;
} else {
TRACEx1(2, "write error, retry %d", retry);
}
} else {
TRACEi(1, "write_segment failed, error:", -result);
break;
}
} else { /* success */
if (result == 0) { /* empty segment */
TRACE(4, "empty segment, nothing written");
}
break;
}
/* Allow escape from loop when signaled !
*/
if (current->signal & _DONT_BLOCK) {
TRACE(2, "interrupted by signal");
TRACE_EXIT;
result = -EINTR; /* is this the right return value ? */
break;
}
}
TRACE_EXIT;
return result;
}
static PyObject *
curve_write_to_file(SKCurveObject * self, PyObject * args)
{
PyObject * pyfile = NULL;
FILE * file = NULL;
CurveSegment * segment;
int i;
if (!PyArg_ParseTuple(args, "O!", &PyFile_Type, &pyfile))
return NULL;
file = PyFile_AsFile(pyfile);
segment = self->segments;
for (i = 0; i < self->len; i++, segment++)
{
if (!write_segment(file, segment))
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
static void create_image(int nfiles, char *files[])
{
int ph, nbytes = 0, first = 1;
FILE *fp, *img;
Elf32_Ehdr ehdr;
Elf32_Phdr phdr;
/* open the image file */
img = fopen(IMAGE_FILE, "w");
assert(img != NULL);
/* for each input file */
while (nfiles-- > 0) {
/* open input file */
printf("%s\n", *files);
fp = fopen(*files, "r");
assert(fp != NULL);
/* read ELF header */
read_ehdr(&ehdr, fp);
printf("0x%04x: %s\n", ehdr.e_entry, *files);
/* for each program header */
for (ph = 0; ph < ehdr.e_phnum; ph++) {
/* read program header */
read_phdr(&phdr, fp, ph, ehdr);
/* write segment to the image */
write_segment(ehdr, phdr, fp, img, &nbytes, &first);
}
fclose(fp);
files++;
}
write_os_size(nbytes, img);
fclose(img);
}
