Jun
29

En los últimos artículos sobre las Macros en C/C++ hemos explicado de una forma un tanto rápida todo el potencial que presenta esta herramienta si sabemos utilizarla con un nivel medio-alto en determinadas situaciones.

Uno de los problemas que se nos presentan en ocasiones a la hora de trabajar en un lenguaje como C es que, a pesar de que contamos con depuradores de código, no siempre tenemos uno a mano, por lo que si a la vez que documentamos podemos mostrar a nuestro capricho y en función de la situación un log de lo que está sucediendo durante su ejecución, podremos hacernos una idea bastante aproximada de si todo va bien o no.

Tras esta pequeña reflexión me lanzo a compartir con vosotros un pequeño fichero .h que nos facilitará enormemente la tarea en una 20 líneas y que he utilizado ya en el desarrollo de varios programas:


#include <stdio.h>
//#define DEBUG 0
#define DEBUG 1
#ifndef __LOG_H
#define __LOG_H
 #if DEBUG == 1
 #define log(format, args...) 
		fprintf (stderr, "%s - %i: ", __FILE__, __LINE__);
		fprintf (stderr, format "n", ##args);
 #define warning(format, args...) 
			log("/!\ "format" /!\", ##args)
#define error(format, args...) 
		log("(X) "format" (X)", ##args)
 #else
#define log(format, args...) ;
#define warning(format, args...) ;
#define error(format, args...) ;
 #endif
#endif

Este fichero tendremos que incluirlo en nuestro programa escrito en C mediante una directiva #include:

#include "log.h"

en este caso he llamado al fichero que contiene esas 20 líneas de código.

De manera que si tenemos declarado DEBUG con un valor de 0 no se mostrará salida alguna y no sólo eso, sino que las líneas desaparecerán (es un claro ejemplo de uso de macros, ya que en nuestro programa en producción puede que deseemos tener más velocidad de procesado y no nos interese interactuar con salidas ni llamar a funciones que no hagan nada), mientras que si tiene un valor de 1, escupirá toda la información que deseemos por, en este caso, la salida de error de nuestro programa.

Si ejecutamos el siguiente programa en C:


#include "log.h"
int main(int argc, char** argv){

log("asdf%i", 1)

log("asdf")

warning("esto es una alerta")

warning("esto es una alerta%i", 1)

error("esto es un error")

error("esto es un error%i", 1)

}

obtendremos la siguiente salida:

bottle.c – 4: asdf1

bottle.c – 5: asdf

bottle.c – 6: /! esto es una alerta /!

bottle.c – 7: /! esto es una alerta1 /!

bottle.c – 8: (X) esto es un error (X)

bottle.c – 9: (X) esto es un error1 (X)

La ausencia de puntos y coma después de llamar las macros no es un error, es que simplemente no hacen falta.

Finalmente y a modo aclaratorio, las constantes utilizadas en el fichero log.h __FILE__ y __LINE__ son dos directivas de preprocesador que nos indican en qué lína y fichero de código tenemos la llamada a ese log.

Categoría C/C++, Producción propia, Programación | 1 Comentario »
May
25

Logo Microsoft .NET

.NET es un lenguaje de programación para equipos Windows que también nos es de gran utilidad a la hora de hacer completas aplicaciones web que necesitan un plano de controlador potente. Por el contrario nos dificulta algunas tareas como las de maquetar el HTML. Me explico: en PHP, cuando ejecutamos un script este siempre genera el código HTML que ha de mostrarse desde 0 a cambio de tener que trabajarnos un poco más el sistema de control de los datos de las páginas usando, por ejemplo, sistemas como el de las sesiones, es decir, tenemos que hacerlo todo “a mano”.

Por el contrario .NET nos ofrece trabajar con los llamados “PostBack”, este sistema de “refresco” de las páginas convierten un sistema sin estado, como son las conexiones HTTP, es una especie de sistema con estado mediante el uso de estructuras como el ViewState.

Esta especie de sistema de conexión con estado hace que, en caso de querer generar HTML de forma dinámica sin plantillas previas, nuestro trabajo pueda convertirse en una ardua tarea.

Para ello podemos hacer uso de una función llamada Page_init ( en lugar o además de Page_load). En esta función, si bien no tiene acceso a estructuras de datos como por ejemplo el ViewState, podemos pintar en el documento un layout HTML a mano antes de que el flujo de la página siga su transcurso, incluso antes de que se cargue el ViewState. Hasta aquí todo normal, y probablemente no le suponga ninguna novedad, peqro ¿Qué pasa cuando hay un PostBack en la pagina que hemos generado de forma dinámica?

Respuesta: si dentro de Page_init no hacemos uso de el condicional !Page.isPostBack, es decir, no ponemos nuestro códig de generación de HTML dentro de un if con esa condición, el código HTML, además de generarse de nuevo, en caso de ser un formulario o algo parecido, este mantendrá los datos introducidos en el mismo antes de hacer dicho PostBack.

Categoría .NET, Manuales, Programación | Sé el primero en comentar!
Feb
23

Hace una semana comentábamos el modo de crear un ListView para Android con, como mínimo, un CheckBox en cada fila de la lista. Este mini tutorial de hoy, en el que vamos a explicar como marcar de una todos los CheckBox de un ListView, vamos a basarnos en el contenido explicado en dicho artículo.

En principio la metodología parece sencilla, en nuestro fichero main.xml, además de declarar un ListView, declaramos en la parte inferior un CheckBox cuyo comportamiento determinaremos más adelante, de manera que el contenido del main.xml quedaría de la siguiente manera:

main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
    <ListView
    	android:id="@+id/list"
    	android:layout_width="fill_parent"
    	android:layout_height="wrap_content"
        android:layout_weight="1"
        android:drawSelectorOnTop="false"/>
	<CheckBox
		android:id="@+id/chkSelectAll"
		android:text="@string/chkSelectAll"
		android:visibility="visible"
		android:layout_width="fill_parent"
		android:layout_height="wrap_content"/>
</LinearLayout>

Hasta aquí todo ha sido coser y cantar, de nuevo hemos de definir un fichero con el Layout de cada una de las filas de lo que será nuestro ListView, en nuestro caso item.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
	android:layout_height="wrap_content"
	android:layout_width="fill_parent">
	<CheckBox
		android:id="@+id/chkItem"
		android:visibility="visible"
		android:layout_width="fill_parent"
		android:layout_height="wrap_content"/>
</LinearLayout>

Una vez que tenemos hecho esto nos bastará con definir el comportamiento de la clase principal para que al marchar el chkSelectAll se marquen todos los CheckBox de la lista, para ello en un principio, con poner el array que determina el valor de cada CheckBox a true o false, en función del caso, debería sernos suficiente. Para ello añadiríamos en el onCreate las liguientes lineas:

        chkAll = (CheckBox)findViewById(R.id.chkSelectAll);
        chkAll.setOnCheckedChangeListener(new OnCheckedChangeListener(){
			@Override
			public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
				for (int i = 0; i < adapter.getItemsLength(); i++) {
    	                                adapter.set(i, b);
    	                        }
			}
        });

El problema nos lo encontramos cuando lo que queremos es que además de marcarlos en el sistema queremos que se visualicen los CheckBox marcados directamente, para ello, lo que podemos hacer (AVISO: es una solución un poco cutre y simplemente para salir del paso) es reasignar el adaptador, para lo que después del for podríamos añadir las siguientes lineas:

        int pos = list.getFirstVisiblePosition();
    	list.setAdapter(adapter);
    	list.setSelection(pos);

Si ahora compilamos y ejecutamos el código podremos observar como el comportamiento es el deseado.

Categoría Android, Manuales, Programación | Sé el primero en comentar!
Feb
16

Android es un gran sistema operativo para móviles que le supone una competencia directa al iOS, y por lo tanto meterse como programador en su mundo puede ser algo muy atractivo. Pero como programadores más o menos experimentados sabemos que no todo es un paseo, tal y como algunos pretenden plantearlo; siempre surgen problemas que habremos de solucionar. Hoy, vamos a ver como evitar que, al tener un ListView en el que cada fila contenga un CheckBox, al hacer scroll, los elementos de la parte no visible se marquen al marcar uno de la parte visible de manera automática.

¿Por qué?

Esto sucede porque Android reutiliza las mismas vistas una y otra vez a la hora de pintar los elementos en pantalla, de manera que aunque el CheckBox que ha de mostrar no está seleccionado, se mostrará como tal dado que uno visible anteriormente ya lo estaba. De este modo se ahorra una gran cantidad de ciclos de CPU a la hora de generar la imagen que se va a mostrar.

Cómo podemos ver, el comportamiento por defecto del sistema operativo no siempre nos viene bien ya que, en casos como este, puede dar lugar a confusiones en el usuario final de la aplicación.

Solución

La manera de solucionar este pequeño inconveniente, aunque no de la forma más óptima, es tan simple como establecer a mano el valor del CheckBox que ha de mostrarse en cada momento, para ello tendremos que apoyarnos en una serie de clases y ficheros XML.

Antes de nada, vamos a analizar los ficheros que componen nuestro Layout, es decir, el que establece la distribución de la pantalla principal y el que establece el aspecto de cada una de las filas.

main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
<ListView
android:id="@+id/list"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_weight="1"
android:drawSelectorOnTop="false"/>
</LinearLayout>

row.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_height="wrap_content"
android:layout_width="fill_parent">
<CheckBox
android:id="@+id/chkItem"
android:visibility="visible"
android:layout_width="fill_parent"
android:layout_height="wrap_content"/>
</LinearLayout>

Tal y como se puede observar, hasta este momento no hemos hecho más que definir dos layouts, uno que contiene un ListView y otro que contiene el CheckBox que ha de aparecer en cada fila.

Prosigamos programando nuestra clase Java para manejar estos Layouts:

package org.dipler.chkList;

import java.util.ArrayList;

import android.app.Activity;
import android.content.Context;
import android.database.Cursor;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.ListView;
import android.widget.CompoundButton.OnCheckedChangeListener;

public class Main extends Activity {
private ChkListAdapter adapter;
private ListView list;
private CheckBox chkAll;

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
list = (ListView)findViewById(R.id.list);
fillList();
}

private void fillList() {
int num = 50;
adapter = new ChkListAdapter(num);
for(int i = 0; i < num; i++){
adapter.addItem(new Item(String.valueOf(i), "item number " + i));
}
list.setAdapter(adapter);
}

private class ChkListAdapter extends BaseAdapter {
private ArrayList<Item> items = new ArrayList<Item>();
private LayoutInflater inflater;
private boolean[] itemSelection;
public ChkListAdapter(int size) {
inflater = (LayoutInflater)getSystemService(Context.LAYOUT_INFLATER_SERVICE);
this.itemSelection = new boolean[size];
}

public void addItem(final Item item) {
items.add(item);
notifyDataSetChanged();
}

@Override
public int getCount() {
return items.size();
}

@Override
public String getItem(int position) {
return items.get(position).toString();
}

@Override
public long getItemId(int position) {
return position;
}

@Override
public View getView(final int position, View convertView, ViewGroup parent) {
convertView = inflater.inflate(R.layout.row, null);
final ViewHolder holder = new ViewHolder();
holder.chkItem = (CheckBox)convertView.findViewById(R.id.chkItem);
holder.chkItem.setOnCheckedChangeListener(new OnCheckedChangeListener(){
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
itemSelection[position] = holder.chkItem.isChecked();
}
});

holder.chkItem.setChecked(itemSelection[position]);
convertView.setTag(holder);
holder.chkItem.setText(getItem(position));
return convertView;
}

public int getItemsLength() {
if(itemSelection == null) return 0;
return itemSelection.length;
}

public void set(int i, boolean b) {
itemSelection[i] = b;
}

}

public static class ViewHolder {
public CheckBox chkItem;
}

}

Como podemos observar el la, bueno, las clases Java que hemos declarado tenemos:

  • La clase Activity principal que utiliza el Layout main.xml y que en el método onCreate() rellena el ListView con elementos, en nuestro caso de tipo Item (Item es una clase cualquiera con dos atributos, un id y un texto)
  • El adapter, que es la clase que se va a dedicar a repintar las filas tantas veces como sea necesario llamando al método getView() en cada una de esas ocasiones.
  • La clase ViewHolder que nos facilita el trabajo con la clase Row, esta clase no es en sí necesaria, pero vi la idea en amberfog y me gustó, de hecho de esta misma página obtuve una visión mucho más clara del funcionamiento de estos artificios llamados “Views”

El procedimiento para evitar que se marquen solos los CheckBox que cumplen el periodo, es sencillo, llevamos un array de booleanos en el que establecemos el estado de cada elemento de la lista confome cambia el valor del CheckBox, de manera que cada vez quedeseemos mostrar dicho elemento, el método getView(), en lugar de pintar como cree que debería pintar estos CheckBox, los muestra marcados o desmarcados en función del array que hemos creado y que vamos actualizando dinámicamente.

El método propuesto no es el más eficiente que nos podamos encontrar, pero funciona y nos puede ayudar a salir del paso.

Categoría Android, Manuales, Programación | 24 Comentarios »
Oct
12

Can’t speak spanish? you can also read this article in english, click here.

Hace ya un tiempo, publiqué una clase para conectar desde PHP con MySQL, dicha clase, si bien cumplía perfectamente con su función, no era eficiente y tampoco le daba mucho juego al programador, así que cuando empecé a desarrollar Keopens, un CMS que empecé a desarrollar con el fin de que fuese un núcleo muy minimalista y adecuado a las nuevas tecnologías que están surgiendo. Por desgracia, no tengo tiempo suficiente para seguir con el desarrollo del mismo, pero algunas clases, si bien forman parte de dicho proyecto, las he sacado del mismo y continuado desarrollando ya que para los pequeños proyectos en PHP que tengo que ir haciendo son muy útiles.

Esta es una de esas clases que han ido creciendo poco a poco y según iban surgiendo necesidades se le iba incrementando las funcionalidades. En general se ha intentado seguir una POO correcta, pero con el fin de compartir la clase aislada, he decidido incluir dos funciones que no deberían estar en dicha clase, una de ellas es la de validar un e-mail y la otra es la de enviarlo.

La clase consta de dos modos de trabajo, un primer modo de debug o testing y un modo de producción, para cambiar entre ambos modos tan sólo hay que cambiarle el valor a una variable, además en el modo testing, la clase nos mostrará, al destruir el objeto o bajo demanda, el número de consultas ejecutadas y el tiempo total entre la creación de la instancia de la clase hasta que esta ha sido borrada. Si ocurre un error grave, y se dan una serie de condiciones (hemos inicializado la clase con un correo electrónico y no estamos en modo testing) se enviará por correo electrónico el fallo, esto es muy útil para tener constancia de los errores e incluso detectar en ocasiones la SQL-Injection en el caso de que se genere una sentencia que no haya podido ser ejecutada debido a errores de sintaxis.

Otras características interesantes:

  • Funciona tanto con conexiones persistentes como no persistentes.
  • Permite la creación de una copia de seguridad de la base de datos escribiendo una única línea de código (MySQL dump desde PHP).
  • Nos permite monitorizar las sentencias, controlando en qué fichero y línea del mismo se ejecuta.
  • Envío de emails cuando sucede un error grave.
  • Conteo de tiempo de ejecución.
  • Conteo de memoria utilizada por el script.
  • Conteo del número de sentencias ejecutadas.
  • Previsualización automática de los datos de salida de una sentencia (modo testing).
  • En bases de datos InnoDB permite el uso de transacciones.
  • Los mensajes extras mostrados en el modo testing tienen asociados una serie de estilos que indican visualmente si la ejecución ha sido correcta o, por el contrario, se ha producido un error.

He aquí una serie de ejemplos muy sencillos para mostrar rápidamente el potencial de la clase.

Para conectar con la base de datos, nos bastará con escribir dos líneas en nuestro programa y ya estaremos listos para trabajar:


$db = new MyMysqli($db_host, $db_uname, $db_pword, $db_name, $debugging, $contactMail, 'MYSQLI_ASSOC');
$db->connect(false);

Para ejecutar una consulta nos basta con escribir una sola directiva.

$query = 'SELECT * FROM text';
$db->execute($query, __LINE__, __FILE__);

Las constantes __FILE__ y __LINE__ nos sirven para indicar, en caso de error, el lugar en el que se encuentra dicha consulta a la base de datos.

El método ejecutado devuelve un resultSet, pero la clase mantiene una referencia al último resultSet dado que es muy probable que nos interese trabajar con él en breves, por lo que devuelve el resultSet para utilizarlo en casos muy específicos, como por ejemplo en el caso de que necesitemos trabajar con dos a la vez.

Para recorrer un resultSet de una consulta nos basta con ir llamando al método fetch(), si no se le pasa como parámetro un resultSet, ejecutará la acción sobre el obtenido en la última petición a la base de datos

if($db->numRows() > 0){
 while($result = $db->fetch()){
//TODO
 }
}

Si somos un poco “vagos” o simplemente vamos a consultar muchas veces los datos, la clase proporciona un método para pasar los datos obtenidos a una tabla.


$db->getTable();

Al igual que en el ejemplo anterior, si no se le pasa como parámetro otro resultSet, formará la tabla partiendo del último restulSet obtenido.

Por último mencionar que, en las primeras lineas de la clase, podrá observar que hay unas líneas comentadas que citan lo siguiente:


//Access control
if(!defined('IN_APP')) exit('Access Forbidden');

Estas líneas están comentadas por una sencilla razón, en PHP es posible acceder a cualquer archivo por URL si el servidor no está bien configurado, esto hace que si la página cargada imprime algo por pantalla, no se muestre, ya que la constante IN_APP no está definida con anterioridad. Por ende para que funcione, antes de incluir el archivo en la ejecución, deberíamos declarar la constante IN_APP. Obviamente el nombre de la constante puede ser cualquiera, en este caso, la que yo usaba en Keopens era IN_APP.

Descarga: [download id="3"]

Categoría PHP, Producción propia, Programación, Web | Sé el primero en comentar!
Sep
15
progress bar vacía

De muchos es sabidos que cualquier aplicación un poco compleja hace recomendable el uso de una barra de progreso para indicar lo que se está haciendo en algún momento dado de la ejecución, como por ejemplo a la hora de procesar grandes cantidades de datos o simplemente al guardar grandes cantidades de datos en un archivo, …

Pues bien, supongamos que, nuestro complejo programa consiste en una barra de progreso y de un botón. Al pulsar el botón, la barra de progreso se llena del 0% al 100% en cuestión de 1 segundo en pasos de 1 en 1, de manera que cada 10ms  el porcentaje de barra rellena tiene que aumentar en 1/100.

progress bar llena

El código de este programa consistiría en algo tan simple como lo siguiente: Continue reading “HOW-TO: JProgressBar no actualiza (Java)” »

Categoría Programación | Sé el primero en comentar!
Jun
20

Con este artículo termina la serie de artículos en las que describimos los principios básicos que hay que tener en cuenta para realizar un chat y en los que también se describe como hacer una pequeña aproximación a uno de estos programas que a muchos de nosotros nos acompañan en nuestro día a día.

En el artículo de hoy vamos a tratar el único tema que nos falta, el cual es el programa cliente que nos servirá a los usuarios para comunicarnos con el servidor y así, poder comunicarnos con el resto de usuarios que se encuentren conectados en un momento dado.

Si bien el cliente se basta de un sólo ejecutable, hoy vamos a tratar dicho ejecutable y otro que nos permita, mediante la redirección de descriptores de ficheros, añadirle una interfaz gráfica sencilla.

cli.c

Nos encontramos ante uno de los ficheros con la lógica esencial del cliente del chat, vamos a analizarlo paso a paso:


#include <stdio.h>
#include <stdlib.h>
// librería para manejo de strings
#include <string.h>
// librería para el uso de los sockets y las correspondientes constantes
#include <sys/socket.h>
// librería para el uso de la constante IPPROTO_TCP, in_addr, ...
#include <netinet/in.h>
// librería que nos permite hacer uso de la variable errno
#include <errno.h>
// librería de base de datos de red
#include <netdb.h>
// librería para el uso de primitivas unix
#include <unistd.h>
// librería para obtener acceso a variables como pid
#include <sys/types.h>
// librería para el manejo de señales
#include <signal.h>
// librería para mostrar la traza del programa
#include "trace.h"
// librería para gestionar los paquetes enviados y recibidos
#include "sms.h"
// librería con las flags que utilizaremos
#include "flags.h"
// incuimos la librería de tipos de datos
#include "type.h"
// incuimos la librería de herramientas para los echo
#include "tools.h"
// incluimos las librerías que nos permitirán hacer uso de SSL
#include "ssl.h"

#define DIM 1024 // definimos el tamaño de los array de textos

#define     READ    STDIN_FILENO
#define     WRITE    STDOUT_FILENO

Incluimos los archivos de cabecera o librerías necesarias para la ejecución del chat y realizamos las definiciones de tamaños, y ya puestos, definimos los descriptores de ficheros de entrada y salida con el nombre de las constantes genéricas en lugar de utilizar los números 0 para lectura y 1 para escritura.

Continue reading “Crea tu propio chat – Cliente” »

Categoría C/C++, Java, Linux, Producción propia, Programación | Sé el primero en comentar!
Jun
19

Hasta ahora hemos estado hablando de funcionalidades genéricas del chat, requisitos, …pues bien hoy vamos a analizar todos los ficheros de los que se compone el servidor y no han sido comentados con anterioridad; al igual que en el artículo anterior, vamos a comentar el cometido de cada una de las funciones de manera genérica, y únicamente nos adentraremos en el contenido de estas en la función de manejo de los sockets y en las que tengan alguna curiosidad que comentar.

Database.c

Éste es un archivo de código fuente que sólo será incluido en el programa del servidor (en realidad también va a ser incluido en el programa que nos ayudará a crear la base de datos desde cero, pero la importancia de ese ejecutable es mínima y la comentaremos más adelante.

En este caso hemos decidido hacer uso del sistema de bases de dados SQLite dado que es una base de datos ligera portable y con características más que suficientes para utilizarla en nuestra pequeña aplicación.

sqlite3* db_open(char*);

El cometido de esta función es simple, simplemente abrirá la base de datos situada en el fichero que se le ha de pasar como argumento.

int db_prepare(sqlite3**);

Esta función no se utilizará en el servidor, pero será la que utilizará la aplicación que creará la base de datos en caso de que esta no exista, y su única función es la de crear las tablas necesarias en la base de datos así como el usuario administrador del chat.

int db_exec(sqlite3**, char*, int);

Esta función se encargará de ejecutar una sentencia SQL y de actuar en consecuencia dependiendo del flag que se le pase como último argumento.

int db_userExists(char*, sqlite3**);

Esta función comprueba si un usuario existe en la base de datos.

int db_checkUser(char*, char*, sqlite3**);

Esta función comprueba si un usuario asociado a una contraseña existe en la base de datos.

int db_addUser(char*, char*, int, sqlite3**);

Crea un nuevo usuario.

int db_deleteUser(char*, sqlite3**);

Elimina un usuario de la base de datos.

int db_listUser(int, sqlite3**);

Lista los usuarios en la base de datos

void db_close(sqlite3**);

Cierra la base de datos y todos los descriptores asociados a ella.

int db_addLog(sms, sqlite3**);

Añade a la tabla de logs un mensaje.

int db_getLog(int, sqlite3**);

Lista el contenido del log de la base de datos

int db_getLogPar(int, sqlite3**, char*);

Tiene un comportamiento similar al de la función anterior, sólo que esta admite parámetros para personalizar la búsqueda, como por ejemplo buscar entre dos fechas dadas.

static int callback(void*, int, char**, char**);

Función que será llamada para cada una de las filas obtenidas de una sentencia SELECT. Continue reading “Crea tu propio chat – Servidor” »

Categoría C/C++, Java, Linux, Producción propia, Programación | Sé el primero en comentar!
Jun
18

Llevamos unos días comentando las características que ha de tener un chat y de cuales son las estructuras básicas en las que podríamos basarnos para crear nuestro propio chat, pues bien, en este artículo vamos a comentar las funciones auxiliares de las que tendremos que hacer uso en un momento u otro en un chat que cumpla una serie de mínimos.

A diferencia de lo que hemos hecho en el artículo anterior, en este, no vamos a comentar el código a menos que se vea necesario y que sea difícil de entender sin una mínima explicación, sino que vamos a analizar las funciones de cada uno de los ficheros de código fuente de funciones auxiliares.

type.c

En este archivo nos encontramos con una serie de funciones que nos permitirán tratar fácilmente tipos de datos como enteros, strings,… quizá el nombre del archivo no sea el más adecuado, pero es lo que hay.

int isNum(char[]);

Ésta es una de las funciones más sencillas y a la vez más útiles de las que podemos encontrarnos, y si bien es bastante probable que la implementación no sea ninguna maravilla, funciona, que para el caso es lo que nos importa, y su cometido principal es determinar si el String que se le pasa como argumento es un número entero o no lo es.

char* ltrim(char*);

char* rtrim(char*);

char* trim(char*);

Estas tres funciones las vamos a comentar juntas, ya que su cometido es muy similar, y es que la primera elimina los espacios en blanco sobrantes a la izquierda del array de caracteres que se le pasa por argumento, la segunda hace lo propio pero por la derecha, y la tercera función llama a las dos anteriormente definidas para, eliminar los espacios en blanco sobrantes a ambos lados de la cadena que se le pasa como argumento.

int addslahses(char*, int, char*);

Esta función es una burda imitación del addslashes de PHP y otros lenguajes para escapar una serie de caracteres antes de almacenar los datos en la base de datos. En este caso concreto la función sólo escapa el carácter de “comilla simple” (). Es una función que debería ser mejorada.

void md5_sum(unsigned char*, int, int, char*);

Por último en este archivo tenemos una función muy interesante, y es que es una función que dado un array de caracteres, es capaz de calcular su suma MD5, algo muy útil para comprobar que los datos transmitidos no han sido corrompidos o, simplemente para crear un sencillo sistema de cifrado de contraseñas en la base de datos y que no puede ser descifrado.

tools.c

En este archivo se definen una serie de funciones que nos servirán para tratar con la consola o bash desde la que ejecutamos nuestro programa.

void echo_on(void);

Esta función habilita el echo por pantalla de todo aquello que tecleemos en la pantalla.

void echo_off(void);

A la inversa que la función descrita anteriormente, ésta se encarga de hacer que lo que se teclee en la bash justo después de haber sido llamada, no se haga echo por pantalla.

void make_daemon(void);

Por último tenemos una función bastante útil y que nos va a permitir desligar el programa en ejecución de la consola y hacer que se ejecute como un demonio según el concepto Unix.

Recuerda que si quieres echarle un vistazo al código completo del chat (tanto cliente como servidor), puedes dirigirte al primer artículo de la serie de artículos que tratan el tema del chat.

Categoría C/C++, Java, Linux, Producción propia, Programación | 1 Comentario »
Jun
17

Para continuar con la serie de artículos de como crear un pequeño chat, vamos a analizar ahora los archivos de cabecera que no están, por unas razones u otras, asociados con ningún archivo *.c; para cada uno de ellos analizaremos el porqué de su existencia y demás temas.

Dado que en el artículo anterior hemos explicado como hacer que un archivo de cabecera sólo se añada una vez en nuestro proyecto (evitando posibles errores de redefiniciones, …), en este artículo vamos a obviar esas partes en la explicación de  los archivos de código fuente.

Código – flags.h:

Éste es un fichero en el que no hay código, no tienen nada especial para explicar, lo único digno de mención de este fichero es que, gracias a él, seremos capaces de identificar fácilmente los tipos de mensajes, clientes,…

Código – socket.h:

Este archivo sí que tiene un poco más de “chicha” como quien dice, en este archivo de cabecera se describen, además de una serie de constantes para identificar el tipo de usuario, el tamaño de algunos campos y variables, se definen una serie de nuevos tipos de datos, el tipo de datos user y el tipo de datos room.


typedef struct usr{
 char name[NAME_LEN];    // nombre del usuario asociado al socket
 int sock;               // información referente al socket de conexión
 SSL *ssl;
 int prov;               // Flag que indica si es provisional o no la conexión
 int rol;                // flag que nos indicará el rol que le hemos asignado
 int room;               // número de la sala a la que está conectado
 }user;

En esta estructura almacenaremos el nombre del usuario asociado a un determinado socket, el socket en cuestión, un objeto de dato que nos permitirá hacer uso de métodos para la comunicación mediante SSL, el indicador de si el usuario se ha identificado, el rol que éste tiene y en qué sala de chat se encuentra.


typedef struct r{
 char name[DIM];
 }room;

Nos encontramos ante un nuevo, pequeño y extensible tipo de datos, y es que gracias a él podemos mantener un registro de las salas de chat activas.

Cabe mencionar que si bien podría ser interesante haber declarado el objeto directamente con un

typedef char name[DIM] room;

se ha hecho así para permitir posibles extensiones de la estructura.

Código – sms.h:

Por último vamos a analizar el contenido de sms.h. Este archivo contiene la definición de una de la estructura que es crucial para el desarrollo del chat, y es que es la estructura que se va utilizar para transmitir entre el cliente y el servidor y viceversa los mensajes.


typedef struct message{
 char text[SMS_LEN];     //mensaje
 time_t time;            //hora del mensaje
 char name[NAME_LEN];    //nombre del que envía el mensaje
 char to[NAME_LEN];       // nombre del destinatario
 int flag;               // flags para comunicar acciones a reaizar
 }sms;

Como puede verse fácilmente, en esta estructura se envía el contenido del mensaje, la fecha y hora en la que se envía el mensaje, el nombre del usuario que envía el mensaje, el nombre del destinatario del mensaje, en caso de que este sea un mensaje privado y un campo flag con el que seremos capaces de indicar que tipo de mensaje es el que se está transmitiendo, esto nos servirá por ejemplo para utilizar la misma estructura para hablar con varios usuarios, un único usuario o incluso directamente con el servidor.

Recuerda que si quieres echarle un vistazo al código completo del chat (tanto cliente como servidor), puedes dirigirte al primer artículo de la serie de artículos que tratan el tema del chat.

Categoría C/C++, Java, Linux, Producción propia, Programación | Sé el primero en comentar!