// Escribe en el array del buzón la representación en bytes del número.
// El formato usado es 'big-endian'.
// Se escriben 2 bytes en la posición indicada, el rango escrito debe estar dentro del array
// de bytes de la instancia.
internal void PonShort(int posicion, short numero)
{
#if DEBUG
Depuracion.Depura(this.almacen == null, "'Buzon' vacío.");
ValidaRango(posicion, 2);
#endif
//
int primero = this.inicio + posicion;
this.almacen [primero] = (byte)(numero >> 8);
this.almacen [primero + 1] = (byte)(numero);
}
// Lee del array del buzón la representación en bytes de un entero corto.
// El formato usado es 'big-endian'.
// Se leen 2 bytes de la posición indicada, el rango leido debe estar dentro del array
// de bytes de la instancia.
internal short TomaShort(int posicion)
{
#if DEBUG
Depuracion.Depura(this.almacen == null, "'Buzon' vacío.");
ValidaRango(posicion, 2);
#endif
//
int primero = this.inicio + posicion;
return((short)(((this.almacen [primero] & 0xff) << 8) |
((this.almacen [primero + 1] & 0xff))));
}
// Lee una secuencia de bytes del array del buzón.
// Los bytes leidos se escriben en 'binario'. El número de bytes leidos es su longitud, que
// no puede ser cero.
// Se lee los bytes de la posición indicada, el rango leido debe estar dentro del array de
// bytes de la instancia.
internal void TomaBinario(int posicion, byte [] binario)
{
#if DEBUG
Depuracion.Depura(this.almacen == null, "'Buzon' vacío.");
Depuracion.Depura(binario == null, "'binario' nula");
Depuracion.Depura(binario.Length == 0, "'binario' vacío");
ValidaRango(posicion, binario.Length);
#endif
//
int destino = this.inicio + posicion;
Buffer.BlockCopy(this.almacen, destino, binario, 0, binario.Length);
}
// Reserva memoria para un array de bytes de la longitud indicada y lo encapsula en la instancia.
// La instancia debe estar previamente vacía.
internal void Reserva(int longitud_)
{
#if DEBUG
Depuracion.Depura(this.almacen != null, "'Buzon' no vacío");
Depuracion.Depura(longitud_ <= 0, "'longitud_' inválida.");
#endif
//
this.almacen = new byte [longitud_];
this.inicio = 0;
this.longitud = longitud_;
this.porciones = 0;
}
// Encapsula en esta instancia el array de bytes indicado.
// No se debe encapsular el mismo array de bytes en dos instancias distintas. Para ello
// están las porciones.
// La instancia debe estar previamente vacía. 'datos' no puede tener longitud cero.
internal void Construye(byte [] datos)
{
#if DEBUG
Depuracion.Depura(this.almacen != null, "'Buzon' no vacío");
Depuracion.Depura(datos == null, "'datos' nulo.");
Depuracion.Depura(datos.Length == 0, "Longitud de 'datos' inválida.");
#endif
//
this.almacen = datos;
this.inicio = 0;
this.longitud = datos.Length;
this.porciones = 0;
}
// Lee del array del buzón la representación en bytes de un entero.
// El formato usado es 'big-endian'.
// Se leen 4 bytes de la posición indicada, el rango leido debe estar dentro del array
// de bytes de la instancia.
internal int TomaInt(int posicion)
{
#if DEBUG
Depuracion.Depura(this.almacen == null, "'Buzon' vacío.");
ValidaRango(posicion, 4);
#endif
//
int primero = this.inicio + posicion;
return(((this.almacen [primero]) << 24) |
((this.almacen [primero + 1] & 0xff) << 16) |
((this.almacen [primero + 2] & 0xff) << 8) |
((this.almacen [primero + 3] & 0xff)));
}
// Reserva memoria para un array de bytes, lo encapsula en la instancia y copia el array de
// bytes 'datos' en él.
// La instancia debe estar previamente vacía. 'datos' no puede tener longitud cero.
internal void ReservaYCopia(byte [] datos)
{
#if DEBUG
Depuracion.Depura(this.almacen != null, "'Buzon' no vacío");
Depuracion.Depura(datos == null, "'datos' nulo.");
Depuracion.Depura(datos.Length == 0, "Longitud de 'datos' inválida.");
#endif
//
this.almacen = new byte [datos.Length];
this.inicio = 0;
this.longitud = datos.Length;
this.porciones = 0;
//
Buffer.BlockCopy(datos, 0, this.almacen, 0, datos.Length);
}
// Asigna 0 a los bytes del array encapsulado en esta instancia.
// Esta instancia no puede ser vacía.
internal void Blanquea()
{
#if DEBUG
Depuracion.Depura(this.almacen == null, "'Buzon' vacío.");
#endif
//
int indice = this.inicio;
int longitud_ = this.longitud;
while (longitud_ > 0)
{
this.almacen [indice] = 0;
indice++;
longitud_--;
}
}
// Reserva memoria para un array de bytes, lo encapsula en la instancia y escribe la cadena de
// caracteres en él.
// Cada caracter de 'datos' se escribe en dos bytes del array, el formato usado es
// 'big-endian'. Por tanto, la longitud del array de bytes es el doble que la de la cadena
// de caracteres.
// La instancia debe estar previamente vacía. 'datos' no puede tener longitud cero.
internal void ReservaYCopia(string cadena)
{
#if DEBUG
Depuracion.Depura(this.almacen != null, "'Buzon' no vacío");
Depuracion.Depura(cadena == null, "'cadena' nulo.");
Depuracion.Depura(cadena.Length == 0, "Longitud de 'cadena' inválida.");
#endif
//
this.almacen = new byte [cadena.Length * 2];
this.inicio = 0;
this.longitud = cadena.Length * 2;
this.porciones = 0;
//
PonString(0, cadena);
}
// Tansforma un buzón en una porción que encapsula un rango del array de bytes de esta
// intancia.
// El buzón a transformar, 'porcion', debe estar vacío.
// La instancia no puede estar vacía ni ser una porción de otro buzón. 'inicio' y
// 'longitud' deben designar un rango válido en el array de bytes.
// En la instancia queda anotado que hay una porción mas creada sobre ella.
internal void ConstruyePorcion(int posicion, int longitud, Buzon porcion)
{
#if DEBUG
Depuracion.Depura(this.almacen == null, "'Buzon' vacío.");
Depuracion.Depura(this.porciones < 0, "Este es porcion de otro 'Buzon'.");
ValidaRango(posicion, longitud);
Depuracion.Depura(porcion == null, "'porcion' nulo.");
Depuracion.Depura(porcion.almacen != null, "'porcion' no vacío.");
#endif
//
porcion.almacen = this.almacen;
porcion.inicio = posicion;
porcion.longitud = longitud;
porcion.porciones = -1;
this.porciones++;
}
// Escribe la cadena de caracteres en el array del buzón.
// Cada caracter se escribe en dos bytes del array, el formato usado es 'big-endian'. Por
// tanto, el número de bytes escritos es el doble de la longitud de la cadena de caracteres.
// Se escriben los bytes en la posición indicada, el rango escrito debe estar dentro del
// array de bytes de la instancia.
internal void PonString(int posicion, string cadena)
{
#if DEBUG
Depuracion.Depura(this.almacen == null, "'Buzon' vacío.");
Depuracion.Depura(cadena == null, "'cadena' nula");
ValidaRango(posicion, cadena.Length * 2);
#endif
//
int destino = this.inicio + posicion;
for (int indice = 0; indice < cadena.Length; ++indice)
{
char caracter = cadena [indice];
this.almacen [destino] = (byte)(caracter >> 8);
this.almacen [destino + 1] = (byte)(caracter);
destino += 2;
}
}
// Lee del array del buzón la representación en bytes de un entero largo.
// El formato usado es 'big-endian'.
// Se leen 8 bytes de la posición indicada, el rango leido debe estar dentro del array
// de bytes de la instancia.
internal long TomaLong(int posicion)
{
#if DEBUG
Depuracion.Depura(this.almacen == null, "'Buzon' vacío.");
ValidaRango(posicion, 8);
#endif
//
int primero = this.inicio + posicion;
return(((((long)this.almacen [primero])) << 56) |
((((long)this.almacen [primero + 1]) & 0xff) << 48) |
((((long)this.almacen [primero + 2]) & 0xff) << 40) |
((((long)this.almacen [primero + 3]) & 0xff) << 32) |
((((long)this.almacen [primero + 4]) & 0xff) << 24) |
((((long)this.almacen [primero + 5]) & 0xff) << 16) |
((((long)this.almacen [primero + 6]) & 0xff) << 8) |
((((long)this.almacen [primero + 7]) & 0xff)));
}
// Escribe en el array del buzón la representación en bytes del número.
// El formato usado es 'big-endian'.
// Se escriben 8 bytes en la posición indicada, el rango escrito debe estar dentro del array
// de bytes de la instancia.
internal void PonLong(int posicion, long numero)
{
#if DEBUG
Depuracion.Depura(this.almacen == null, "'Buzon' vacío.");
ValidaRango(posicion, 8);
#endif
//
int primero = this.inicio + posicion;
this.almacen [primero] = (byte)(numero >> 56);
this.almacen [primero + 1] = (byte)(numero >> 48);
this.almacen [primero + 2] = (byte)(numero >> 40);
this.almacen [primero + 3] = (byte)(numero >> 32);
this.almacen [primero + 4] = (byte)(numero >> 24);
this.almacen [primero + 5] = (byte)(numero >> 16);
this.almacen [primero + 6] = (byte)(numero >> 8);
this.almacen [primero + 7] = (byte)(numero);
}
// Libera la memoria usada por esta instancia, dejandola vacía.
// Esta instancia no puede ser una porción, ni debe haber porciones de esta instancia.
internal void Libera()
{
if (this.almacen == null)
{
return;
}
//
#if DEBUG
// no actua en buzón vacío
Depuracion.Depura(this.porciones < 0, "Este es porcion de otro 'Buzon'.");
Depuracion.Depura(this.porciones > 0, "Quedan porciones de este 'Buzon'.");
#endif
//
this.almacen = null;
this.inicio = 0;
this.longitud = 0;
this.porciones = 0;
}
// Devuelve y asigna un byte del array encapsulado, el situado en la posicion indicada.
// Su es una porción, se toma la posición a partir del inicio de la porción.
// No puede ser una instancia vacía.
internal byte this [int posicion] {
get {
#if DEBUG
Depuracion.Depura(this.almacen == null, "'Buzon' vacío.");
ValidaRango(posicion, 1);
#endif
//
return(this.almacen [this.inicio + posicion]);
}
set {
#if DEBUG
Depuracion.Depura(this.almacen == null, "'Buzon' vacío.");
ValidaRango(posicion, 1);
#endif
//
this.almacen [this.inicio + posicion] = value;
}
}
internal void Envia(int longitud)
{
Depuracion.Depura(de_servidor, "me he hecho un lío");
Depuracion.Depura(longitud != conexion.BuzonPaquete.Longitud, "me he hecho un lío");
//
if (contador_CTR_local.NumeroSerie == 0 &&
contador_CTR_local.NumeroMensaje == 0)
{
//
Depuracion.Depura(!de_cliente, "'billete' o 'indice' fuera de lugar");
//
MensajeInicio mensaje_claves = new MensajeInicio(this);
mensaje_claves.Envia();
//
MensajeSeguridad mensaje_billete =
new MensajeSeguridad(this, MensajeSeguridad.Tipologia.Inicio);
mensaje_billete.RecibeBillete();
//
}
//
TimeSpan tiempo = DateTime.Now - contador_tiempo;
if (contador_bytes > 200 ||
tiempo.TotalMinutes > 20)
{
contador_CTR_local.AnulaMensaje();
contador_CTR_remoto.AnulaMensaje();
}
//
if (contador_CTR_local.NumeroMensaje == 0)
{
//
MensajeSeguridad mensaje_seguridad =
new MensajeSeguridad(this, MensajeSeguridad.Tipologia.Secreto);
mensaje_seguridad.EnviaSecreto();
//
MensajeSeguridad mensaje_billete =
new MensajeSeguridad(this, MensajeSeguridad.Tipologia.Billete);
mensaje_billete.RecibeBillete();
//
}
//
mensaje_general.Envia();
}
// Lee una serie de caracteres del array del buzón y los escribe en una cadena caracteres.
// Cada caracter de se lee de dos bytes del array, el formato usado es 'big-endian'.
// El número de caracteres leidos es 'longitud_' y el número de bytes leidos es el doble.
// Se lee los bytes de la posición indicada, el rango leido debe estar dentro del array de
// bytes de la instancia.
// Antes de escribir los caracteres en 'cadena', esta se vacía.
internal void TomaString(int posicion, int longitud_, StringBuilder cadena)
{
#if DEBUG
Depuracion.Depura(this.almacen == null, "'Buzon' vacío.");
Depuracion.Depura(cadena == null, "'cadena' nula");
ValidaRango(posicion, longitud_ * 2);
#endif
//
cadena.Length = 0;
int indice = this.inicio + posicion;
for (int cuenta = 0; cuenta < longitud_; ++cuenta)
{
char caracter =
(char)(((this.almacen [indice] & 0xff) << 8) |
((this.almacen [indice + 1] & 0xff)));
cadena.Append(caracter);
indice += 2;
}
}
// Anula una porción de esta instancia, dejandola vacía.
// El buzón anulado ('porcion') debe ser una porción previamente construida sobre esta
// instancia.
// En la instancia queda anotado que hay una porción menos creada sobre ella.
internal void AnulaPorcion(Buzon porcion)
{
#if DEBUG
Depuracion.Depura(this.almacen == null, "'Buzon' vacío.");
Depuracion.Depura(this.porciones < 0, "Este es porcion de otro 'Buzon'.");
Depuracion.Depura(this.porciones == 0, "Este no tiene porciones.");
Depuracion.Depura(porcion == null, "'porcion' nulo");
Depuracion.Depura(porcion.almacen == null, "'porcion' vacío");
Depuracion.Depura(porcion.porciones >= 0, "'porcion' no es un porcion'");
Depuracion.Depura(porcion.almacen != this.almacen,
"'porcion' no es porcion de este");
#endif
//
porcion.almacen = null;
porcion.inicio = 0;
porcion.longitud = 0;
porcion.porciones = 0;
this.porciones--;
}
internal void Recibe()
{
Depuracion.Depura(de_servidor, "me he hecho un lío");
//
if (contador_CTR_local.NumeroSerie == 0 &&
contador_CTR_local.NumeroMensaje == 0)
{
Depuracion.Depura(!de_servicio, "'billete' o 'indice' fuera de lugar");
//
MensajeInicio mensaje_claves = new MensajeInicio(this);
mensaje_claves.Recibe();
//
MensajeSeguridad mensaje_billete =
new MensajeSeguridad(this, MensajeSeguridad.Tipologia.Inicio);
mensaje_billete.EnviaBillete();
}
//
int indice;
mensaje_general.RecibeCabecera(out indice);
//
if (indice == 0)
{
//
contador_CTR_local.AnulaMensaje();
contador_CTR_remoto.AnulaMensaje();
//
MensajeSeguridad mensaje_seguridad =
new MensajeSeguridad(this, MensajeSeguridad.Tipologia.Secreto);
mensaje_seguridad.IntegraCabecera(mensaje_general);
mensaje_seguridad.RecibeSecreto();
//
MensajeSeguridad mensaje_billete =
new MensajeSeguridad(this, MensajeSeguridad.Tipologia.Billete);
mensaje_billete.EnviaBillete();
//
mensaje_general.RecibeCabecera(out indice);
//
}
//
mensaje_general.RecibeCuerpo();
}
// Traslada el array de bytes encapsulado desde el buzón indicado, hasta esta instancia.
// Esta instancia se vacía antes del traslado. 'origen' queda vacío tras el traslado.
// Ni esta instancia ni 'origen' pueden ser porciones, ni pueden tener porciones construidas
// sobre ellos.
internal void TrasponBuzon(Buzon origen)
{
#if DEBUG
// admite buzon vacío y no vacío
Depuracion.Depura(this.porciones < 0, "Este es porción de otro 'Buzon'.");
Depuracion.Depura(this.porciones > 0, "Quedan porciones de este 'Buzon'.");
Depuracion.Depura(origen == null, "'origen' nulo");
Depuracion.Depura(origen.almacen == null, "'origen' vacío.");
Depuracion.Depura(origen.porciones < 0, "'origen' es porcion de otro 'Buzon'.");
Depuracion.Depura(origen.porciones > 0, "Quedan porciones de 'origen'.");
#endif
//
this.almacen = origen.almacen;
this.inicio = origen.inicio;
this.longitud = origen.longitud;
this.porciones = origen.porciones;
origen.almacen = null;
origen.inicio = 0;
origen.longitud = 0;
origen.porciones = 0;
}
// Copia el array de bytes de un buzón en otro buzón.
// Los buzones deben ser de la misma longitud y no puede ser vacíos.
// Los buzones puede ser porciones (uno o los dos). En tal caso se copia el rango que
// especifican.
internal static void CopiaDatos(Buzon origen, Buzon destino)
{
#if DEBUG
Depuracion.Depura(origen == null, "'origen' nulo");
Depuracion.Depura(destino == null, "'destino' nulo");
Depuracion.Depura(origen.almacen == null, "'origen' vacío");
Depuracion.Depura(destino.almacen == null, "'destino' vacío");
Depuracion.Depura(origen.longitud != destino.longitud, "'origen' y 'destino' de longitudes distintas");
#endif
//
int indice_origen = origen.inicio;
int indice_destino = destino.inicio;
int longitud = origen.longitud;
while (longitud > 0)
{
destino.almacen [indice_destino] = origen.almacen [indice_origen];
indice_origen++;
indice_destino++;
longitud--;
}
}
// Copia una parte del array de bytes de un buzón en otro buzón.
// El rango de bytes a copiar, tanto en 'origen' como en 'destino', es de 0 a 'longitud_'-1.
// El rango debe ser válido en ambos buzones.
// Los buzones puede ser porciones (uno o los dos). En tal caso, el rango a copiar se toma
// dentro del rango de la porción.
internal static void CopiaDatos(Buzon origen, Buzon destino, int longitud_)
{
#if DEBUG
Depuracion.Depura(origen == null, "'origen' nulo");
Depuracion.Depura(destino == null, "'destino' nulo");
Depuracion.Depura(origen.almacen == null, "'origen' vacío");
Depuracion.Depura(destino.almacen == null, "'destino' vacío");
origen.ValidaRango(0, longitud_);
destino.ValidaRango(0, longitud_);
#endif
//
int indice_origen = origen.inicio;
int indice_destino = destino.inicio;
while (longitud_ > 0)
{
destino.almacen [indice_destino] = origen.almacen [indice_origen];
indice_origen++;
indice_destino++;
longitud_--;
}
}
// Cambia una porción de esta instancia, modificando la longitud del rango del array de
// bytes, en la medida indicada.
// El buzón cambiado ('porcion') debe ser una porción previamente construida sobre esta
// instancia.
// Tras el cambio, 'porcion' debe designar un rango válido en el array de bytes.
internal void RedimensionaPorcion(Buzon porcion, int medida)
{
#if DEBUG
Depuracion.Depura(porcion == null, "'porcion' nulo");
Depuracion.Depura(this.almacen == null, "'Buzon' vacío.");
Depuracion.Depura(this.porciones < 0, "Este es porcion de otro 'Buzon'.");
Depuracion.Depura(this.porciones == 0, "Este no tiene porciones.");
Depuracion.Depura(porcion.almacen == null, "'porcion' es vacío");
Depuracion.Depura(porcion.porciones >= 0, "'porcion' no es un porcion'");
Depuracion.Depura(porcion.almacen != this.almacen,
"'porcion' no es porcion de este");
// this.inicio será 0
int poscn_fragm = porcion.inicio;
int final_fragm = porcion.inicio + porcion.longitud - 1;
final_fragm += medida;
Depuracion.Depura(final_fragm < poscn_fragm, "'medida' inválida.");
Depuracion.Depura(this.longitud - 1 < final_fragm, "'porcion' se situa fuera");
#endif
//
porcion.longitud += medida;
}
private void ValidaRango(int posicion_, int longitud_)
{
Depuracion.Depura(posicion_ < 0, "'posicion' inválida.");
Depuracion.Depura(longitud_ <= 0, "'longitud' inválida.");
Depuracion.Depura(this.longitud <= posicion_ + longitud_ - 1, "'posicion' o 'longitud' inválidas.");
}