void checkForResponse(){
char c = localClient.read();
Serial.print(c);
buff[pointer] = c;
if (pointer < 64) pointer++;
if (c == '\n') {
found = strstr(buff, "200 OK");
if (found != 0){
found_status_200 = true;
//Serial.println("Status 200");
}
buff[pointer]=0;
found_content = true;
clean_buffer();
}
if ((found_session_id) && (!found_CSV)){
found = strstr(buff, "HTTP/1.1");
if (found != 0){
char csvLine[strlen(buff)-9];
strncpy (csvLine,buff,strlen(buff)-9);
//Serial.println("This is the retrieved CSV:");
//Serial.println("---");
//Serial.println(csvLine);
//Serial.println("---");
Serial.println("\n--- updated: ");
Serial.println(pachube_data);
Serial.println("\n--- retrieved: ");
char delims[] = ",";
char *result = NULL;
char * ptr;
result = strtok_r( buff, delims, &ptr );
int counter = 0;
while( result != NULL ) {
remoteSensor[counter++] = atof(result);
result = strtok_r( NULL, delims, &ptr );
}
for (int i = 0; i < REMOTE_FEED_DATASTREAMS; i++){
Serial.print( (int)remoteSensor[i]); // because we can't print floats
Serial.print("\t");
}
found_CSV = true;
Serial.print("\nsuccessful updates=");
Serial.println(++successes);
}
}
if (found_status_200){
found = strstr(buff, "_id=");
if (found != 0){
clean_buffer();
found_session_id = true;
}
}
}
//gets operation as user input
void get_operation(int* operation) {
puts("Willkommen im Menue. Waehlen Sie eine Option aus.");
puts("0 = neuen Datensatz hinzufuegen\t1 = Datensaetze ausgeben\t2 = Programm beenden");
while(scanf(" %d", operation) != 1 || (*operation < 0 || *operation > 2)) {
puts("Wrong input. Bitte geben Sie eine gueltige Ziffer (0-2) ein");
clean_buffer();
} clean_buffer();
}
void handle_disconnect(){
maxfd = 0;
client_connection_id = 0;
FD_ZERO(&fds);
FD_SET(0, &fds);
logged=0;
clean_buffer(client_send_buffer);
clean_buffer(client_recv_buffer);
}
static void unique_run(void)
{
read_buffer();
if (use_to_unique_but_not_add)
clean_buffer();
write_buffer();
while (!feof(fpInput)) {
read_buffer();
clean_buffer();
write_buffer();
if (verbose)
printf ("\rTotal lines read "LLu" Unique lines written "LLu"\r", totLines, written_lines);
}
}
bool write_to_socket(int fd, buffer_t *buf)
{
bool close_connection = false;
// add message length at the beginning of the message
uint16_t msg_length = htons((uint16_t) buf->msg_length);
memmove(&buf->buffer[sizeof(msg_length)], &buf->buffer[0], buf->msg_length);
memcpy(&buf->buffer[0], (char*)&msg_length, sizeof(msg_length));
buf->in_buffer += sizeof(msg_length);
buf->msg_length += sizeof(msg_length);
do {
ssize_t bytes_send = send(fd, &buf->buffer[0], buf->msg_length, 0);
if (bytes_send < 0) {
if (errno != EWOULDBLOCK)
syserr("send() failed");
}
// remove send bytes
buf->msg_length -= bytes_send;
memmove(&buf->buffer[0], &buf->buffer[bytes_send], buf->msg_length);
} while (buf->msg_length != 0);
// clean buffer
clean_buffer(buf, true);
return close_connection;
}
void Escola::pedeInstrutorEliminar() {
vector<Instrutor*>::iterator it;
int i = 1, escolha;
cout << "\nInstrutores : \n \n";
for (it = instrutores.begin(); it != instrutores.end(); it++) {
cout << i << "- " << (*it)->getNome() << "\n";
i++;
}
cout << "\nEscolha o instrutor a eliminar (0 para sair): ";
cin >> escolha;
clean_buffer();
try {
if (escolha < 0 || escolha > i) {
throw escolha;
}
} catch (...) {
cout << "Escolha invalida, tente outra vez\n\n";
pedeInstrutorEliminar();
}
if (escolha == 0)
veiculo();
escolha--;
it = instrutores.begin() + escolha;
vector<Aula *>::iterator it_aulas;
for (it_aulas = aulas.begin(); it_aulas != aulas.end(); it_aulas++) {
if ((*it_aulas)->getInstrutor().getNome() == (*it)->getNome()) {
aulas.erase(it_aulas);
if (aulas.size() == 0)
break;
}
}
instrutores.erase(instrutores.begin() + escolha);
}
void Escola::escolherVeiculos() {
{
vector<Veiculo *>::iterator it;
unsigned int i = 1;
unsigned int choice;
vector<Aula *>::iterator it2;
for (it = veiculos.begin(); it != veiculos.end(); it++) {
cout << i << " - " << (*it)->getMarca() << " - "
<< (*it)->getMatricula() << "\n";
i++;
}
cout << "Escolha o veiculo que quer ver as aulas : ";
cin >> choice;
clean_buffer();
choice--;
it = veiculos.begin() + choice;
i = 1;
for (it2 = aulas.begin(); it2 != aulas.end(); it2++) {
if ((*it2)->getVeiculo().getMatricula() == (*it)->getMatricula()) {
cout << i << " - " << (*it2)->getInstrutor().getNome() << " - "
<< (*it2)->getAluno().getNome() << " - "
<< (*it2)->getHora() << "h - dia: " << (*it2)->getDia()
<< "\n";
i++;
}
}
}
}
void Escola::VeiculoDisp() {
vector<Veiculo*>::iterator it;
int i = 1, escolha;
cout << "\nVeiculos : \n \n";
for (it = veiculos.begin(); it != veiculos.end(); it++) {
cout << i << "- " << (*it)->getMarca() << "-" << (*it)->getMatricula()
<< "\n";
i++;
}
cout << "Escolha o veiculo a mudar disponibilidade (0 para sair): ";
cin >> escolha;
clean_buffer();
try {
if (escolha < 0 || escolha > i) {
throw escolha;
}
} catch (...) {
cout << "Escolha invalida, tente outra vez\n\n";
VeiculoDisp();
}
if (escolha == 0)
veiculo();
escolha--;
veiculos[escolha]->mudarDispon();
}
playfield::playfield ( int sizex, int sizey, int ofsX, int ofsY )
{
maxX = sizex;
maxY = sizey;
pixOfsX = ofsX;
pixOfsY = ofsY;
numLoadedTiles = 0;
numSprites = 0;
ticker = 0;
usrInput = move_left;
// game data
lives = 3;
score = 0;
// level data
pill_duration = 400;
ghost_hatch_time = 100;
ghost_iq[0] = 10;
ghost_iq[1] = 20;
ghost_iq[2] = 30;
ghost_iq[3] = 40;
ghost_path_time = 32;
dot_value = 10;
big_dot_value = 50;
fruit_frequency = 1000;
fruit_duration = 100;
fruit_value = 200;
fruit_value_icon = 0;
if ( DosAllocMem ( (PPVOID) &field, sizex * sizey * sizeof(int),
(ULONG) PAG_COMMIT | PAG_READ | PAG_WRITE) )
Eng_Abort("Error while opening up some system RAM for playfield.");
if ( DosAllocMem ( (PPVOID) &frontBuffer, sizex * sizey * sizeof(backtile*),
(ULONG) PAG_COMMIT | PAG_READ | PAG_WRITE) )
Eng_Abort("Error while opening up some system RAM for display frontBuffer.");
if ( DosAllocMem ( (PPVOID) &backBuffer, sizex * sizey * sizeof(backtile*),
(ULONG) PAG_COMMIT | PAG_READ | PAG_WRITE) )
Eng_Abort("Error while opening up some system RAM for display backBuffer.");
// don't try to release the objects in the buffer since they are invalid
clean_buffer (frontBuffer,0);
clean_buffer (backBuffer,0);
}
LASreaderBuffered::LASreaderBuffered() : points_per_buffer(10000)
{
lasreader = 0;
buffer_size = 0.0f;
buffers = 0;
clean();
clean_buffer();
}
static void unique_run(void)
{
read_buffer();
if (use_to_unique_but_not_add)
clean_buffer();
write_buffer();
while (!feof(fpInput)) {
read_buffer();
clean_buffer();
write_buffer();
if (verbose)
#ifdef __MINGW32__
printf ("\rTotal lines read %I64u Unique lines written %I64u\r", totLines, written_lines);
#else
printf ("\rTotal lines read %llu Unique lines written %llu\r", totLines, written_lines);
#endif
}
}
int read_cmd(t_client *client)
{
char buffer[BUFFER_SIZE];
memset(buffer, 0, BUFFER_SIZE);
fgets(buffer, 512, stdin);
clean_buffer(buffer);
if (!strlen(buffer))
{
return (-1);
}
else if (strlen(buffer) > 0 && (client->tab = my_str_to_wordtab(buffer)))
{
client->buffer_in = buffer;
check_command(client, client->tab);
free_wordtab(&(client->tab));
}
return (0);
}
void Escola::pedeInstrutor() {
string nome;
vector<string> VI;
vector<Instrutor*>::iterator it;
cout << "Nome do instrutor: ";
getline(cin, nome);
clean_buffer();
for (it = instrutores.begin(); it != instrutores.end(); it++) {
if (nome == (*it)->getNome()) {
cout << "O instrutor já existe \n";
instrutor();
}
}
VI = adicionarVeiculos();
Instrutor *I = new Instrutor(nome, VI);
adicionaInstrutor(I);
}
void Escola::pedeAluno() {
string nome;
vector<Aluno*>::iterator it;
cout << "Nome do aluno: ";
getline(cin, nome);
clean_buffer();
cout << "\n";
for (it = alunos.begin(); it != alunos.end(); it++) {
if (nome == (*it)->getNome()) {
cout << "O aluno já existe \n";
aluno();
}
}
Aluno *A = new Aluno(nome);
adicionaAlunos(A);
vagas--;
}
char save_tkp(t_tekpaint *tekpaint)
{
char *buffer;
int readv;
if (NULL == (buffer = bunny_malloc(sizeof(char)*101)))
return (0);
clean_buffer(buffer, 101);
my_putstr("Entrez le chemin du fichier à sauvegarder : ");
readv = read(0, buffer, 100);
remove_carriage_return(buffer);
buffer = my_strcat(buffer, ".tkp");
if (save_pixelarray(buffer, tekpaint->workplan.buffer) && readv > 0)
{
my_putstr("Fichier sauvegardé vers : ");
my_putstr(buffer);
my_putchar('\n');
}
else
my_putstr("Erreur durant la sauvegarde, try again\n");
bunny_free(buffer);
return (1);
}
void* server_answer(void* arg){
int *sock = (int*)arg;
char buffer[255];
char aux[255];
char *buffer_it = buffer;
int n,part,i=0,tam;
command_header cmmd;
while(1){
clean_buffer(buffer,sizeof(buffer));
//fgets(buffer, sizeof(buffer), fp);
//printf("%c \n",buffer[0]);
tam = n = recv(sock[0],&cmmd,sizeof(command_header) ,0);
//tam = n = recv(sock[0],&buffer,sizeof(buffer) ,0);
printf("server_answer:Number of bytes received: %d\n",n);
//printf("command:%s\n",buffer);
printf("%d %d\n",cmmd.command,cmmd.size,cmmd.p);
for(i=0;i<(int)cmmd.size;i++){
printf("%x\n",cmmd.p[i]);
}
}
}
void initialize_shell(SHELL * shell)
{
char * msg = "tpeARQ:$>";
int i, j;
for ( i = 0; i < SCREEN_SIZE ; i++)
{
if (i % 2 == 0)
shell->screen[i] = 0;
else
shell->screen[i] = 0;
}
i = 0, j = 0;
while (msg[j])
{
shell->screen[i] = msg[j++];
i++;
shell->screen[i] = 0;
i++;
}
clean_buffer(shell);
shell->cursor = (strlen(msg)-1) * 2;
shell->current_line = 0;
update_cursor(shell);
}
void Escola::pedeAlunoEliminar() {
vector<Aluno*>::iterator it;
int i = 1, escolha;
cout << "\n\nAlunos : \n \n";
for (it = alunos.begin(); it != alunos.end(); it++) {
cout << i << "- " << (*it)->getNome() << "\n";
i++;
}
cout << "\nEscolha o aluno a eliminar (0 para sair): ";
cin >> escolha;
clean_buffer();
try {
if (escolha < 0 || escolha > i) {
throw escolha;
}
} catch (...) {
cout << "Escolha invalida, tente outra vez\n\n";
pedeAlunoEliminar();
}
if (escolha == 0)
aluno();
escolha--;
it = alunos.begin() + escolha;
vector<Aula *>::iterator it_alunos;
for (it_alunos = aulas.begin(); it_alunos != aulas.end(); it_alunos++) {
if ((*it_alunos)->getAluno().getNome() == (*it)->getNome()) {
aulas.erase(it_alunos);
if (aulas.size() == 0)
break;
}
}
alunos.erase(alunos.begin() + escolha);
vagas++;
}
int main(int argc , char *argv[])
{
int r_bytes;
char user_input[STDIN_BUFFER_SIZE];
char* arg1 = NULL;
char* arg2 = NULL;
int cmd;
init_client("127.0.0.1", 8888);
maxfd = 0;
client_connection_id = 0;
while (run){
FD_ZERO(&fds);
if (logged)
FD_SET(client_connection_id, &fds); //al establecer conexion tengo que hacerlo.
FD_SET(0, &fds); //stdin
select(maxfd+1, &fds, NULL, NULL, NULL);
if (FD_ISSET(0, &fds)){
fgets(user_input, STDIN_BUFFER_SIZE, stdin);
if (*user_input == '\n')
continue;
cmd = parse_cmd(user_input, &arg1, &arg2);
switch(cmd) {
case CMD_CHAT:
write_talk(user_input);
break;
case CMD_LOGIN:
write_login(arg1, arg2, DEFAULT_COLOR);
break;
case CMD_REGISTER:
write_register(arg1, arg2);
break;
case CMD_LOGOUT:
write_disconnect();
break;
case CMD_CH_PW:
write_change_pw(arg1);
break;
case CMD_CH_PRIVS:
write_change_privileges(arg1, (unsigned char)(*arg2 - '0'));
break;
case CMD_CH_COLOR:
write_change_color((unsigned char)(*arg1 - '0'));
break;
case CMD_DELETE_USER:
write_delete();
break;
case CMD_KICK:
write_kick(arg1, arg2);
break;
case CMD_BAN:
write_ban(arg1, arg2);
break;
case CMD_GET_ONLINE_USERS:
write_get_online_users();
break;
case CMD_HELP:
show_help();
break;
case CMD_ERROR:
fprintf(stderr, "Comando no reconocido. Escriba /help para ver la lista de comandos...\n");
break;
}
if (arg1 != NULL){
free(arg1);
}
if (arg2 != NULL){
free(arg2);
}
arg1 = arg2 = NULL;
}
if (logged && FD_ISSET(client_connection_id, &fds)){
r_bytes = load_buffer(client_connection_id, client_recv_buffer);
while (client_recv_buffer->pos + 1 < r_bytes){
handle_tcp_packets();
client_recv_buffer->pos+=1;
}
clean_buffer(client_recv_buffer);
}
}
deinit_client();
return 0;
}
extern "C" void *lp_it_to_ot_buffer(void *fake) {
/* variables internes */
LP_global_audio_data audio_data;
int i, m, y, ot_ite = 0;
int err;
/* buffer interne */
if(audio_data.it_size < 1){
fprintf(stderr, "lp_it_to_ot_buffer: it_size is not defined\n");
pthread_exit(0);
}
float *buffer = (float *)malloc(audio_data.it_size * sizeof(float));
if(buffer == NULL) {
fprintf(stderr, "lp_it_to_ot_buffer: failed to allocate memory for buffer\n");
pthread_exit(0);
}
/* mutex */
if((err = pthread_mutex_init(&audio_data.it_ot_buffer_mutex, NULL)) != 0){
fprintf(stderr, "lp_it_to_ot_buffer: unable to initialize it_ot_buffer_mutex\n");
exit(-1);
}
/* On positionne play_buf_full[] a 1 */
for(i=0; i<audio_data.nb_players; i++){
audio_data.play_buf_full[i] = 1;
}
/* On indique qu'on est pret */
audio_data.it_to_ot_ready = 1;
while(1 > 0) {
/* Pour chaque player */
for(i=0; i<audio_data.nb_players; i++){
/* Si le player est en pause, on passe */
if(audio_data.player_mode[i] == LP_PLAY_MODE_PLAYING) {
/* On donne le top (des que play_buf_full == 0 -> player va ecire) */
audio_data.play_buf_full[i] = 0;
//printf("Top donne a %d\n", i);
/* On attends que le buffer soit plein */
while((audio_data.play_buf_full[i] != 1) && (audio_data.player_mode[i] == LP_PLAY_MODE_PLAYING)){
usleep(1000);
}
/* copie du buffer */
for(y=0; y<audio_data.it_size; y++) {
buffer[y] = audio_data.mixed_buffer[y];
}
}
}
/* On calcule le Nbre d'iterations qu'il faut pour transmettre ot_buffer:
si rd_size / ot_size est non entier, il faut un tour de plus pour le reste */
/* determin how many iterations we need to transmit frames to output */
if((audio_data.it_size % audio_data.ot_size) != 0 ) {
ot_ite = (audio_data.it_size / audio_data.ot_size) + 1;
} else {
ot_ite = audio_data.it_size / audio_data.ot_size;
}
/* On remplis ot_buffer */
/* fill the buffer */
m = 0;
for(i = 0; i < ot_ite; i++) {
while (audio_data.ot_full != 0) {
usleep(1000);
}
pthread_mutex_lock(&audio_data.it_ot_buffer_mutex);
for(y=0; y<(audio_data.ot_size); y++) {
audio_data.ot_buffer[y] = buffer[y+m];
}
/* taille du buffer [frames] */
audio_data.ot_full = 1;
audio_data.ot_frames_to_read = audio_data.ot_size / audio_data.nb_channel;
pthread_mutex_unlock(&audio_data.it_ot_buffer_mutex);
/* avance dans it_buffer */
m = m + audio_data.ot_size;
}
/* On nettoie les buffers de bus (sinon, echo lors du mixage!) */
/* clean buffer (echo problems else) */
clear_bus_buffers(0);
/* clean buffer (else ringbuffer problems whenn passing in pause mode) */
clean_buffer(audio_data.mixed_buffer, audio_data.it_size);
}
free(buffer);
}
//
// Update the field, showing all sprites in their (new?) positions e.t.c.
playfield::update( int redraw )
{
///////////////////////////
// build the frontbuffer //
///////////////////////////
// with sprites
for (int i=0; i < numSprites; i++)
{
int x1,y1,o1,d1,x2,y2,o2,d2;
// find out which positions our sprite will occupy
Sprites[i]->get_position ( x1, y1, o1, d1, x2, y2, o2, d2 , maxX-1, maxY-1);
// replicate those backtiles, if they aren't allready in the frontbuffer
if (frontBuffer[ x1+y1*maxX ]==NULL)
frontBuffer[ x1+y1*maxX ] = new tile ( *get_field_position(x1,y1) );
if (frontBuffer[ x2+y2*maxX ]==NULL)
frontBuffer[ x2+y2*maxX ] = new tile ( *get_field_position(x2,y2) );
// superimpose the sprite on them..
frontBuffer[ x1+y1*maxX ]->overlay ( *(Sprites[i]->get_crnt_tile()), o1, d1 );
frontBuffer[ x2+y2*maxX ]->overlay ( *(Sprites[i]->get_crnt_tile()), o2, d2 );
}
// and changed tiles:
for (i=0; i<numLoadedTiles; i++)
if (backgroundTiles[i]->is_changed())
for (int x=0; x<maxX; x++)
for (int y=0; y<maxY; y++)
if (frontBuffer[x+y*maxX]==NULL && field[x+y*maxX] == i)
frontBuffer[x+y*maxX] = new tile (*get_field_position(x,y));
// update display :
// for each position do :
// nothing, if both front and backBuffer are NULL
// show background, if only backBuffer != NULL
// show front, if frontBuffer is != NULL
tile* crnt;
int cnt = 0;
for (int y=0; y<maxY; y++)
for (int x=0; x<maxX; x++, cnt++)
{
crnt = NULL;
if (backBuffer[cnt] || redraw)
crnt = backgroundTiles [ field[cnt] ]->get_crnt_tile();
if (frontBuffer[cnt])
crnt = frontBuffer[cnt];
if (crnt)
crnt->show ( pixOfsX + x * tileWidth, pixOfsY + (fieldSizeY-y-1) * tileHeight );
}
// make the frontbuffer a backbuffer...
clean_buffer (backBuffer);
switch_buffers();
// you're done!
return 0;
}
/*
** show_commands - show table of commands with keyboard shortcuts
*/
int
show_commands (void)
{
int ret=1;
LINE *lp=NULL;
char circle_line[1024];
char key_buff[90];
char name_buff[30];
int ti, ki, i, j, mi;
/* open or reopen? */
ret = scratch_buffer("*cmds*");
if (ret) {
return (ret);
}
/* cnf.ring_curr is set now -- CURR_FILE and CURR_LINE alive */
if (CURR_FILE.num_lines > 0) {
clean_buffer();
}
CURR_FILE.fflag |= FSTAT_SPECW;
CURR_FILE.fflag &= ~FSTAT_NOEDIT; /* temporary */
ret = type_text("\n\
command name function name keyboard shortcut\n\
-------------------- -------------------- -------------------------\n");
if (!ret) {
CURR_LINE = CURR_FILE.bottom->prev;
memset(circle_line, '\0', sizeof(circle_line));
memset(name_buff, '\0', sizeof(name_buff));
memset(key_buff, '\0', sizeof(key_buff));
for (ti=0; ret == 0 && ti < TLEN; ti++) {
if (table[ti].minlen == -1 && table[ti].fkey == -1) {
/* only for macros */
continue;
}
/* command name with mandatory or optional arguments */
name_buff[0] = '\0';
if (table[ti].minlen >= 1) {
i = 0;
for (j=0; i < 20 && table[ti].name[j] != '\0'; j++) {
if (i == table[ti].minlen)
name_buff[i++] = '.';
name_buff[i++] = table[ti].name[j];
}
name_buff[i++] = '\0';
if (table[ti].tflag & TSTAT_ARGS) {
strncat(name_buff, ((table[ti].tflag & TSTAT_OPTARG) ? " [<arg>]" : " <arg>"), 10);
}
} else {
strncpy(name_buff, "n/a", 10);
}
/* list of keys, pretty printing, space limitation */
key_buff[0] = '\0';
if (table[ti].fkey == -1) {
strncpy(key_buff, "n/a", 10);
} else {
for (ki=0; ki < KLEN; ki++) {
if (keys[ki].table_index == ti) {
if (pretty_print_key_names(ki, key_buff, sizeof(key_buff)))
break;
}
}
if (key_buff[0] == '\0') {
strncat(key_buff, "none", 10);
}
}
snprintf(circle_line, sizeof(circle_line)-1, "%-20s %-20s %s\n",
name_buff, table[ti].fullname, key_buff);
ret = type_text(circle_line);
}
}
if (!ret && macros) {
ret = type_text("\n\
macro key macro name\n\
-------------------- ----------------------------------------\n");
for (mi=0; ret == 0 && mi < MLEN; mi++) {
key_buff[0] = '\0';
ki = index_key_value( macros[mi].fkey );
if (ki >= 0 && ki < KLEN && ki != RES_KLEN) { // KEY_NONE index is RES_KLEN
pretty_print_key_names(ki, key_buff, sizeof(key_buff));
} else {
strncpy(key_buff, "none", 10);
}
name_buff[0] = '\0';
if (macros[mi].name[0] == '\0') {
strncpy(name_buff, "n/a", 10);
} else {
strncpy(name_buff, macros[mi].name, 20);
if (macros[mi].mflag & TSTAT_ARGS) {
strncat(name_buff, ((macros[mi].mflag & TSTAT_OPTARG) ? " [<arg>]" : " <arg>"), 10);
}
}
snprintf(circle_line, sizeof(circle_line)-1, "%-20s %s\n",
key_buff, name_buff);
ret = type_text(circle_line);
}
}
/*
** list_buffers - open a special buffer with a list of open files and bookmarks,
** switch to the open buffer or (re)generate it
*/
int
list_buffers (void)
{
int ri, lno_read;
LINE *lp=NULL, *lx=NULL;
char one_line[CMDLINESIZE*2];
int ret=1, bm_i;
int origin = cnf.ring_curr;
/* open or reopen? */
ret = scratch_buffer("*ring*");
if (ret==0) {
/* switch to */
if (origin != cnf.ring_curr && CURR_FILE.num_lines > 0)
return (0);
/* generate or regenerate */
if (CURR_FILE.num_lines > 0)
ret = clean_buffer();
}
if (ret) {
return (ret);
}
CURR_FILE.num_lines = 0;
CURR_FILE.fflag |= (FSTAT_SPECW);
if (origin != cnf.ring_curr) {
CURR_FILE.origin = origin;
}
/* fill with data from ring
*/
CURR_FILE.num_lines += cnf.ring_size;
lp = CURR_FILE.bottom->prev;
lno_read = 0;
memset(one_line, 0, sizeof(one_line));
for (ri=0; ret==0 && ri<RINGSIZE; ri++) {
if (!(cnf.fdata[ri].fflag & FSTAT_OPEN))
continue;
/* base data
*/
if (cnf.fdata[ri].fflag & (FSTAT_SPECW | FSTAT_SCRATCH)) {
snprintf(one_line, sizeof(one_line)-1, "%d \"%s\" lines: %d flags: %s%s%s%s\n",
ri, cnf.fdata[ri].fname, cnf.fdata[ri].num_lines,
(cnf.fdata[ri].fflag & FSTAT_SPECW) ? "special " : "",
(cnf.fdata[ri].fflag & FSTAT_SCRATCH) ? "scratch " : "",
(cnf.fdata[ri].fflag & FSTAT_CHMASK) ? "r/o " : "",
(cnf.fdata[ri].pipe_output != 0) ? "pipe " : "");
} else {
snprintf(one_line, sizeof(one_line)-1, "%d \"%s\" lines: %d flags: %s%s%s%s\n",
ri, cnf.fdata[ri].fname, cnf.fdata[ri].num_lines,
(cnf.fdata[ri].fflag & FSTAT_RO) ? "R/O " : "R/W ",
(cnf.fdata[ri].fflag & FSTAT_CHANGE) ? "Mod " : "",
(cnf.fdata[ri].fflag & FSTAT_EXTCH) ? "Ext.Mod " : "",
(cnf.fdata[ri].fflag & FSTAT_HIDDEN) ? "HIDDEN " : "");
}
if ((lx = append_line (lp, one_line)) != NULL) {
lno_read++;
lp=lx;
} else {
ret = 2;
break;
}
/* optional: bookmarks
*/
for (bm_i=1; bm_i < 10; bm_i++) {
if (ri == cnf.bookmark[bm_i].ring) {
snprintf(one_line, sizeof(one_line)-1, "\tbookmark %d: %s\n",
bm_i, cnf.bookmark[bm_i].sample);
if ((lx = append_line (lp, one_line)) != NULL) {
lno_read++;
lp=lx;
} else {
ret = 2;
break;
}
}
}
}/* for ri... */
if (ret==0) {
CURR_FILE.num_lines = lno_read;
CURR_LINE = CURR_FILE.top->next;
CURR_FILE.lineno = 1;
update_focus(FOCUS_ON_2ND_LINE, cnf.ring_curr);
go_home();
CURR_FILE.fflag &= ~FSTAT_CHANGE;
/* disable inline editing and adding lines */
CURR_FILE.fflag |= (FSTAT_NOEDIT | FSTAT_NOADDLIN);
} else {
ret |= drop_file();
}
return (ret);
}
BOOL LASreaderBuffered::remove_buffer()
{
clean_buffer();
if (header.vlr_lasoriginal) npoints = header.vlr_lasoriginal->number_of_point_records;
return header.restore_lasoriginal();
}
/**
* jpeg file : need to updata pdvr->disp_bitmap to display;
* video: need to call dispFlip();
**/
int dvr_thmb_dispFullScreen(cdvr_thmb_t *pdvr, char *disp_pData)
{
int ret = -1;
SINT64 stime, etime;
gp_bitmap_t *pbitmap= NULL;
if(!pdvr) {
return -1;
}
char *purl = NULL;
int type = -1;
dvr_thmb_setDispFullMode(pdvr);
if(DispBufManage.DispDev == C_DISP_BUFFER) {
pdvr->upFrame = (unsigned char *)get_idle_buffer(0);
clean_buffer(pdvr->upFrame, 0);
}
else {
pdvr->upFrame = (char *)dispGetFramebuffer(pdvr->hDisp);
}
pdvr->pUrl = FilelistGetFilePath(pdvr->pFile, dvr_thmb_getCurIdxOfFile(pdvr));
pdvr->fileType = checkFileType(pdvr->pUrl);
printf("[%s:%d]curIdx %d curPage %d pageNum %d type %d\n", __FUNCTION__, __LINE__, pdvr->cur_idx, pdvr->cur_page, pdvr->cur_pageNum, pdvr->fileType);
purl = pdvr->pUrl;
type = pdvr->fileType;
photo_uninit(pdvr->pPhotoInfo); //for jpeg->video->jpeg
pdvr->pPhotoInfo = NULL;
if(purl) {
stime = sysGetCurTime();
ret = -1;
if(type == GP_FILE_TYPE_VIDEO) {
pbitmap= &pdvr->disp_bitmap;
pbitmap->pData = (unsigned char*)pdvr->upFrame;
ret = mcpGetThumbnail(pbitmap, purl, 0);
}
else if(type == GP_FILE_TYPE_JPEG) {
pdvr->pPhotoInfo = photo_init(purl, &pdvr->disp_bitmap);
if(pdvr->pPhotoInfo) {
pdvr->pPhotoInfo->bitmap->pData = (unsigned char*)pdvr->upFrame;
ret = image_scale(pdvr->pPhotoInfo);
if(ret == -1) {
}
}
}
etime = sysGetCurTime();
printf("thumbnail used time %lld - %lld = %lldms ret %d\n", etime, stime, etime - stime, ret);
if(ret == -1) {
//dispCleanFramebuffer(pdvr->hDisp);
if(DispBufManage.DispDev == C_DISP_BUFFER) {
pdvr->upFrame = (unsigned char *)get_idle_buffer(0);
clean_buffer(pdvr->upFrame, 0);
}
else {
pdvr->upFrame = (char *)dispGetFramebuffer(pdvr->hDisp);
dispCleanFramebuffer(pdvr->hDisp);
}
printf("WARNNING: get fulscreen error!!!!!!!\n");
}
}
dvr_thmb_dispFlip(pdvr);
return ret;
}
int dvr_thmb_setFileNumber(cdvr_thmb_t *pdvr, int file_num, int reset)
{
if(!pdvr) {
return -1;
}
//int lastFileNum = pdvr->file_number;
int idx = dvr_thmb_getCurIdxOfFile(pdvr);
printf("f:%d idx %d\n",pdvr->file_number, idx);
if(pdvr->file_number == idx) { //delete last file
reset = 1;
}
pdvr->file_number = file_num;
pdvr->disp_page = file_num/(pdvr->disp_number);
if(file_num%(pdvr->disp_number)) {
pdvr->disp_page++;
}
#if 0
if(pdvr->cur_idx == -1) {
pdvr->cur_idx = 0;
}
else if(pdvr->cur_idx >= pdvr->file_number) {
pdvr->cur_idx = 0;
pdvr->cur_page = 0;
}
if(pdvr->cur_page == -1) {
pdvr->cur_page = pdvr->disp_page-1;
}
if(pdvr->cur_page == pdvr->disp_page-1) {
pdvr->cur_pageNum = pdvr->file_number % pdvr->disp_number;
pdvr->cur_pageNum = pdvr->cur_pageNum?pdvr->cur_pageNum:pdvr->disp_number;
}
else {
pdvr->cur_pageNum = pdvr->disp_number;
}
#else
if(pdvr->disp_page) {
if(reset) {
pdvr->cur_page = pdvr->disp_page-1;
pdvr->cur_pageNum = pdvr->file_number%pdvr->disp_number;
pdvr->cur_pageNum = pdvr->cur_pageNum?pdvr->cur_pageNum:pdvr->disp_number;
pdvr->cur_idx = pdvr->cur_pageNum-1;
}
else { //not reset and not delete the last file
//if(pdvr->cur_idx-1)
//pdvr->cur_page = pdvr->disp_page-1;
//pdvr->cur_pageNum = pdvr->file_number%pdvr->disp_number;
//pdvr->cur_pageNum = pdvr->cur_pageNum?pdvr->cur_pageNum:pdvr->disp_number;
}
//pdvr->cur_idx = pdvr->cur_pageNum-1;
if(fileMode && pdvr->file_number > 1) {
idx = dvr_thmb_getCurIdxOfFile(pdvr);
if(FileNameMatch(FilelistGetFilePath(pdvr->pFile, idx), FilelistGetFilePath2(pdvr->pFile, idx-1)) >= 0) {
dvr_thmb_preIdx(pdvr);
}
}
}
#endif
printf("[%s:%d]curIdx %d curPage %d pageNum %d \n", __FUNCTION__, __LINE__, pdvr->cur_idx, pdvr->cur_page, pdvr->cur_pageNum);
pdvr->dispMode = DISP_FULL_SCREEN;
if(!pdvr->disp_page) {
pdvr->dispMode = DISP_NO_FILE;
if(DispBufManage.DispDev == C_DISP_BUFFER) {
pdvr->upFrame = (unsigned char *)get_idle_buffer(0);
clean_buffer(pdvr->upFrame, 0);
}
else {
pdvr->upFrame = (char *)dispGetFramebuffer(pdvr->hDisp);
dispCleanFramebuffer(pdvr->hDisp);
}
pdvr->disp_page = -1;
pdvr->cur_idx = -1;
pdvr->cur_page = -1;
pdvr->cur_pageNum = -1;
dvr_thmb_dispFlip(pdvr);
}
else {
pdvr->pUrl = FilelistGetFilePath(pdvr->pFile, dvr_thmb_getCurIdxOfFile(pdvr));
}
return 0;
}
//////////////////////////////////////////////////////////////////////////////////////////////
// //
// Main function //
// //
//////////////////////////////////////////////////////////////////////////////////////////////
int main(void)
{ //Test
int last_nombre = 4;
char str[64] = "Test de String...";
unsigned char distanceActuel = 0;
//Variables protocole de liaison de donnée
char trame_a_envoye = 0, trame_complete = 0, trameRX[NBROCTET], trameTX[NBROCTET];
//Initial configuration
setup_oscillator();
config();
//Init fifo
fifo_init();
radio_dir(TRM_RX); //Module en réception
//Display welcome screen: ToDo
#ifdef USE_GLCD
GLCD_Bitmap((char*)Base1, 0, 0, 128, 64);
#endif
//Test
// index = 0;
// while(1)
// {
// // result = get_offset(dirty_buf[index], dirty_buf[index + 1], flag);
// result = get_flag(flag);
// Nop();
// clean_buffer(result, 16);
// Nop();
// }
//Main loop
while (1)
{
#ifdef AUTO
routine_auto(&trame_a_envoye, &trame_complete, trameTX, trameRX);
#endif
#ifdef BORNE
routine_borne(&trame_a_envoye, &trame_complete, trameTX, trameRX);
#endif
//Test: encodeur et GLCD
if((last_nombre != nombre) || buttonPress) //Si une transition a eu lieu
{
#ifdef USE_GLCD
GLCD_ClearScreen();
GLCD_Bitmap((char*)Base1, 0, 0, 128, 64);
if(buttonPress && !toEcran1)
{
BORNERESERVE = nombre;
GLCD_GoTo(0,5);
GLCD_WriteString(RESERVE);
toEcran1 = 1;
}
else if(buttonPress && toEcran1)
{
toEcran1 = 0;
BORNERESERVE = 3;
confirm=2;
}
sprintf(str,"%d",SERIALBATTERIE);
GLCD_GoTo(107,0);
GLCD_WriteString(str);
#endif
switch(nombre)
{
case 0:
#ifdef USE_GLCD
DISTANCE = D1;
GLCD_GoTo(0,2);
GLCD_WriteString(ADR1A);
if(!toEcran1)
{
GLCD_GoTo(0,3);
GLCD_WriteString(ADR2);
GLCD_GoTo(0,4);
GLCD_WriteString(ADR3);
}
#endif
break;
case 1:
#ifdef USE_GLCD
DISTANCE = D2;
GLCD_GoTo(0,3);
GLCD_WriteString(ADR2A);
if(!toEcran1)
{
GLCD_GoTo(0,2);
GLCD_WriteString(ADR1);
GLCD_GoTo(0,4);
GLCD_WriteString(ADR3);
}
#endif
break;
case 2:
#ifdef USE_GLCD
DISTANCE = D3;
if(!toEcran1)
{
GLCD_GoTo(0,2);
GLCD_WriteString(ADR1);
GLCD_GoTo(0,3);
GLCD_WriteString(ADR2);
}
GLCD_GoTo(0,4);
GLCD_WriteString(ADR3A);
#endif
break;
default:
#ifdef USE_GLCD
GLCD_ClearScreen();
GLCD_Bitmap((char*)Base1, 0, 0, 128, 64);
#endif
break;
}
#ifdef USE_GLCD
GLCD_GoTo(90,7);
GLCD_WriteString(METER);
distanceActuel = DISTANCE;
buttonPress = 0;
last_nombre = nombre;
if(confirm==2)
{
if(D1<DISTANCEPROCHE){
borneProche(0);
}
else if(D2<DISTANCEPROCHE){
borneProche(1);
}
else if(D3<DISTANCEPROCHE){
borneProche(2);
}
if(confirm==1)
{
buttonPress=1;
toEcran1=0;
}
else if(confirm==0)
{
buttonPress=0;
toEcran1=0;
last_nombre=4;
}
}
#endif
}
//Données sortantes
if(trame_a_envoye == 1)
{
envoie = rf_envoie(trameTX, (char *)clean_buf);
if(envoie == 1)
trame_a_envoye = 0;
}
//Flags - Données entrantes
if(rf_flag == 1)//&& trame_complete == 0)
{
//Actualise la batterie
#ifdef USE_GLCD
getBatt();
sprintf(str,"%03i",BATTERIE);
GLCD_GoTo(80,0);
if(nombre==0)
{DISTANCE = D1;}
else if(nombre==1)
{DISTANCE = D2;}
else if(nombre==2)
{DISTANCE = D3;}
GLCD_WriteString(str);
sprintf(str,"%i",DISTANCE);
GLCD_GoTo(40,7);
GLCD_WriteString(str);
#endif
result = get_flag(flag);
if(result != 10)
{
clean_buffer(result, 32);
//Extraction des octets vers la couche application
trame_complete = rf_gerer_RX((char *)clean_buf, trameRX);
}
//Remise à zéro de la détection
rf_flag = 0;
result = 10;
}
//
#ifdef GPS_FEEDTHROUGH
//TestGPS
#ifdef DEBUG_MPSIM
gps_flag =1; //REMOVE
#endif
if(gps_flag)
{
gps_flag = 0;
//Filtre les données quand le buffer est plein
#ifdef DEBUG_MPSIM
(gpsstr[3]='R'); //REMOVE
#endif
if((gpsstr[3]=='R'))
{
for(a =0;a<47;a++)
{
gps[a] = gpsstr[a]; //Buffer de travail
}
// puts_usart1(gpsstr);
//gps[] = "$GPRMC,174254.000,V,4522.75800,N,07155.43400,W";
#ifdef DEBUG_MPSIM
gps[20]='4';
gps[21]='5';
gps[22]='2';
gps[23]='2';
gps[25]='7';
gps[26]='5';
gps[27]='8';
gps[33]='0';
gps[34]='7';
gps[35]='1';
gps[36]='5';
gps[37]='5';
gps[39]='4';
gps[40]='3';
gps[41]='4';
gps[45]='W';
#endif
convStr();
//LaA = 45.3793;
//LoA= -71.9239;
assignDist(LaA,LoA);
}
}
#endif
/*
#ifdef USE_GLCD
if(buttonPress)
{
switchScreen(last_nombre);
buttonPress = 0;
}
if(distanceActuel < DISTANCEBATT && BATTERIE < 50 && ecran ==2)
{
switchBatt();
}
#endif
*/
if(buttonPress)
{
#ifdef BORNE
buttonPress = 0;
char donnee_test[NBROCTET] = {0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37};
envoie = rf_envoie(donnee_test, (char *)clean_buf);
#endif
#ifdef AUTO
puts_usart1(gps);
#endif
}
if(rssi_flag)
{
rssi_flag = 0;
//Filtre les données quand le buffer est plein
rssi = get_rssi();
}
}
return 0;
}
int start_pcanywhere(int s, char *ip, int port, unsigned char options, char *miscptr, FILE * fp) {
char *empty = "";
char *login, *pass;
char buffer[2048] = "";
char clogin[128] = "";
char cpass[128] = "";
int ret, i;
char *client[4];
char *server[5];
int clientsize[4];
client[0] = "\x00\x00\x00\x00";
clientsize[0] = 4;
client[1] = "\x6F\x06\xff";
clientsize[1] = 3;
client[2] = "\x6f\x61\x00\x09\x00\xfe\x00\x00\xff\xff\x00\x00\x00\x00";
clientsize[2] = 14;
client[3] = "\x6f\x62\x01\x02\x00\x00\x00";
clientsize[3] = 7;
server[0] = "nter";
server[1] = "\x1B\x61";
server[2] = "\0x1B\0x62";
server[3] = "Enter login name";
server[4] = "denying connection";
if (strlen(login = hydra_get_next_login()) == 0)
login = empty;
if (strlen(pass = hydra_get_next_password()) == 0)
pass = empty;
debugprintf("dans pcanywhere start");
/*printf("testing %s:%s\n",login,pass); */
strcpy(clogin, login);
strcpy(cpass, pass);
pca_encrypt(clogin);
pca_encrypt(cpass);
for (i = 0; i < 4; i++) {
if (hydra_send(s, client[i], clientsize[i], 0) < 0) {
return 1;
}
ret = hydra_recv(s, buffer, sizeof(buffer));
if (ret == -1) {
return 1;
}
if (i == 3) {
if (ret == 3) {
/*one more to get the login prompt */
ret = hydra_recv(s, buffer, sizeof(buffer));
}
}
if (i == 0 || i == 3)
clean_buffer(buffer, ret);
/*show_buffer(buffer,ret); */
if (i == 2) {
clean_buffer(buffer, ret);
if (strstr(buffer, server[i + 2]) != NULL) {
fprintf(stderr, "[ERROR] PC Anywhere host denying connection because you have requested a lower encrypt level\n");
return 3;
}
}
if (strstr(buffer, server[i]) == NULL) {
if (i == 3) {
debugprintf("problem receiving login banner");
}
return 1;
}
}
if (send_cstring(s, clogin) < 0) {
return 1;
}
ret = hydra_recv(s, buffer, sizeof(buffer));
if (ret == -1) {
return 1;
}
clean_buffer(buffer, ret);
/*show_buffer(buffer,ret); */
if (strstr(buffer, "Enter password:"******"problem receiving password banner");
return 1;
}
if (send_cstring(s, cpass) < 0) {
return 1;
}
ret = hydra_recv(s, buffer, sizeof(buffer));
if (ret == -1) {
return 1;
}
clean_buffer(buffer, ret);
/*show_buffer(buffer,ret); */
if ((strstr(buffer, "Invalid login") != NULL) || (strstr(buffer, "Enter password") != NULL)) {
debugprintf("login/passwd wrong");
hydra_completed_pair();
if (memcmp(hydra_get_next_pair(), &HYDRA_EXIT, sizeof(HYDRA_EXIT)) == 0)
return 3;
return 2;
} else {
debugprintf("cool find login/passwd");
hydra_report_found_host(port, ip, "pcanywhere", fp);
hydra_completed_pair_found();
if (memcmp(hydra_get_next_pair(), &HYDRA_EXIT, sizeof(HYDRA_EXIT)) == 0)
return 3;
return 2;
}
return 1;
}
