Mensajes

... hay gentuza que no debería ser padre !!!!  Pobre criaturita, repudiada por la persona ...

Bueno hasta tu la llamas "criatura".

Dulces Lunas!¡.

Usa hilos... Así matas el hilo en el momento que desees.

Dulces Lunas!¡.

[Está prohibido poner links con Adf.ly. Sé perfectamente que con estos links conseguirás dinero (lo he visto a menudo).]

Está prohibido poner links con Adf.ly. Sé perfectamente que con estos links conseguirás dinero (lo he visto a menudo).

A jijos eso donde lo dice que no estoy enterado!¡.

http://foro.elhacker.net/sugerencias_y_dudas_sobre_el_foro/caren_v10_reglamento_de_convivencia_y_contenido-t17721.0.html

Dulces Lunas!¡.

mmm una manera mas "simple" es obteniendo las tablas TCP/IP (estructuras) y establecerlas con el estado de puerto cerrado...

No trabajo ya con VB pero aquí lo tienes, hay que usar Google.

http://foro.elhacker.net/programacion_visual_basic/cerrar_un_puerto_se_puede-t308247.0.html;msg1530906#msg1530906

Código (vb) [Seleccionar] Expandir



'
'   /////////////////////////////////////////////////////////////
'   // Autor:   BlackZeroX ( Ortega Avila Miguel Angel )       //
'   //                                                         //
'   // Web:     http://InfrAngeluX.Sytes.Net/                  //
'   //                                                         //
'   //    |-> Pueden Distribuir Este codigo siempre y cuando   //
'   // no se eliminen los creditos originales de este codigo   //
'   // No importando que sea modificado/editado o engrandecido //
'   // o achicado, si es en base a este codigo                 //
'   /////////////////////////////////////////////////////////////

Option Explicit

Enum StadosPort
  UNKNOWN = 0
  CLOSED = 1
  LISTENING = 2
  SYN_SENT = 3
  SYN_RCVD = 4
  ESTABLISHED = 5
  FIN_WAIT1 = 6
  FIN_WAIT2 = 7
  CLOSE_WAIT = 8
  CLOSING = 9
  LAST_ACK = 10
  TIME_WAIT = 11
  DELETE_TCB = 12
End Enum
Type MIB_TCPROW
  dwState As StadosPort
  dwLocalAddr As Long
  dwLocalPort As Long
  dwRemoteAddr As Long
  dwRemotePort As Long
End Type
Type MIB_TCPTABLE
  dwNumEntries As Long
  table(100) As MIB_TCPROW
End Type
Public MIB_TCPTABLE As MIB_TCPTABLE
Public Declare Function GetTcpTable Lib "iphlpapi.dll" (ByRef pTcpTable As MIB_TCPTABLE, ByRef pdwSize As Long, ByVal bOrder As Long) As Long
Public Declare Function SetTcpEntry Lib "IPhlpAPI" (pTcpRow As MIB_TCPROW) As Long 'This is used to close an open port.
Public Declare Function ntohs Lib "WSOCK32.DLL" (ByVal netshort As Long) As Long
Private Declare Function CreateWindowEx Lib "user32" Alias "CreateWindowExA" (ByVal dwExStyle As Long, ByVal lpClassName As String, ByVal lpWindowName As String, ByVal dwStyle As Long, ByVal x As Long, ByVal y As Long, ByVal nWidth As Long, ByVal nHeight As Long, ByVal hWndParent As Long, ByVal hMenu As Long, ByVal hInstance As Long, lpParam As Any) As Long
Private Declare Function SetTimer Lib "user32" (ByVal hwnd As Long, ByVal nIDEvent As Long, ByVal uElapse As Long, ByVal lpTimerFunc As Long) As Long
'Private Declare Function KillTimer Lib "user32" (ByVal hwnd As Long, ByVal nIDEvent As Long) As Long
Private Declare Function WaitMessage Lib "user32" () As Long

Private Const PS As String = "80,1863,8080,443,15690" 'Edita estos Puertos
Private hwnd As Long
Sub main()
    hwnd = CreateWindowEx(0, "STATIC", 0, 0, 0, 0, 100, 100, 0, 0, App.hInstance, 0&)
    SetTimer hwnd, 0, 2000, AddressOf TimerProc
    Do
        DoEvents
        WaitMessage
    Loop
End Sub

Public Sub TimerProc(ByVal hwnd As Long, ByVal nIDEvent As Long, ByVal uElapse As Long, ByVal lpTimerFunc As Long)
    Dim TCPTable As MIB_TCPTABLE
    Dim Ports() As String
    Dim i%, p%
    GetTcpTable TCPTable, Len(TCPTable), 0
    Ports = Split(PS, ",")
    For i = 0 To TCPTable.dwNumEntries - 1
        For p = 0 To UBound(Ports) - 1
            If Ports(p) = ntohs(TCPTable.table(i).dwRemotePort) Then
                GoTo Salto:
            ElseIf (p = Val(UBound(Ports) - 1)) Then
                TCPTable.table(i).dwState = DELETE_TCB
                SetTcpEntry TCPTable.table(i)
                Debug.Print ntohs(TCPTable.table(i).dwRemotePort)
                GoTo Salto:
            End If
        Next p
Salto:
    Next i
End Sub



Dulces Lunas!¡.

Bien gracias, los typedef los dejare para tipos simples de datos como punteros a funciones y evitando usarlos en struct y union.

Creo que compilare de vez en cuando en modo paranoico ( Para revisar algunas cosillas, errores y ver avisos ) pero terminare compilando con -w.

Dejo esto por si a alguien le interesa.

C99
http://www.iso.org/iso/home/store/catalogue_ics/catalogue_detail_ics.htm?csnumber=29237
http://atrey.karlin.mff.cuni.cz/projekty/vrr/doc/c99.pdf

C11
http://www.iso.org/iso/home/store/catalogue_ics/catalogue_detail_ics.htm?csnumber=57853

Dulces Lunas!¡.

cuando lo tenga podre probarlo y no fallar 100 veces como hasta ahora  .

Si no te equivocas no aprendes...

Dulces Lunas!¡.

Gracias.

De hecho me estoy leyendo TODOS los parámetros para el compilador gcc , además del las "normas" del C99 y ando viendo un poco del C11 (Se ve bueno).

http://gcc.gnu.org/onlinedocs/gcc-4.0.4/gcc/C-Dialect-Options.html
http://gcc.gnu.org/onlinedocs/gcc-4.0.4/gcc/Warning-Options.html

* A mi lo único que me molesta son esos avisos, los errores me parecen MUY LÓGICOS e innegables para el cast.
* Con respecto al cast de tipos y al peformance no lo se si los cast se hacen en tiempo de compilación o se traducen a opcodes (creo que así se llama, corrijan-me) si es lo primero entonces no veo mayor problema, aun que como bien se ve declaro varios typedef como:

list_t que es equivalente a un void* pero que a su vez es equivalente (para las funciones) a list_data_ptr_t que es equivalente a list_data_t* y a su vez struct list_data*...

list_t que = void* = list_data_ptr_t = list_data_t* = struct list_data*

o uno mas corto:

list_value_t = intptr_t y como en un intptr_t se puede agregar sin problema un void* o alguna dirección... los cast a mi parecer serian solo un plus... y es por ello mi problemática, de hecho ya es mas una problemática de decisión de usar o no los typedef.

P.D.: No creo que sea muy buen ejemplo atoi() atoi no es un cast es una funcion y en lugar de usar atoi seria mejor usar strtol() o strtoll() hay mas control de errores.

Dulces Lunas!¡

usa doble \\ en lugar de una sola \

printf("\\n \\t hola mundo \\n\\t");
puts("\\n \\t hola mundo \\n\\t");

Dulces Lunas!¡.

.
¿Es bueno hacer varios cast de tipos?, Se que es recomendable pero no lo se hasta que punto.

por ejemplo:

list.h

Código (c) [Seleccionar] Expandir



typedef
enum {
   LIST_CMP_EQUAL          = 0x0,
   LIST_CMP_LESS_THAT      = 1,
   LIST_CMP_GREATER_THAT   = -1
} list_cmp_t;

typedef enum {
   LIST_SORT_ASC,
   LIST_SORT_DESC
} list_sort_t;

typedef void*               list_t;
typedef list_t*             list_ptr_t;

typedef intptr_t            list_value_t;
typedef list_value_t*       list_value_ptr_t;

typedef list_value_ptr_t    list_item_t;
typedef list_item_t*        list_item_ptr_t;

typedef size_t              list_size_t;
typedef list_size_t*        list_size_ptr_t;

/** Definición de Callback que se encarga de crear un duplicado del list_value_t indicado en parámetro value.
* @param value: list_value_t que se duplicara.
* @return Retorna el elemento list_value_t duplicado del parámetro value.
*/
typedef list_value_t(*list_callback_clone_item)(const list_value_t value);

/** Definicion de Callback que se encarga de destruir la memoria asignada al list_value_t.
* @param value: list_value_t que se liberara.
*/
typedef void(*list_callback_release_item)(const list_value_t value);

/** Definicion de CALLBACK que se encarga comparar dos list_value_t.
* @param value1: list_value_t que se comparara con value2.
* @param value2: list_value_t que se comparara con value1.
* @return Retorna el resultado de la comparación.
*    AVL_CMP_LESS_THAT: Si value1 < value2.
*    AVL_CMP_EQUAL: Si value1 == value2.
*    AVL_CMP_GREATER_THAT: Si value1 > value2.
*/
typedef list_cmp_t(*list_callback_compare_item)(const list_value_t value1, const list_value_t value2);


/** Crea una nueva lista de elementos list_value_t.
* @param clone_item: Apuntador a la función CALLBACK que retornara la copia del valor a asignar.
* @param release_item: Apuntador a la función CALLBACK que liberara la copia del valor duplicado en el list_callback_clone_item.
* @param clone_item: Apuntador a un proceso CALLBACK que se encarga de comparar los list_item_t.
* @return Retorna la nueva cola de datos queue_t que debera ser destruida con list_release().
*/
list_t list_allocator(list_callback_clone_item clone_item, list_callback_release_item release_item, list_callback_compare_item compare_item);



Código (c,36) [Seleccionar] Expandir



/** Tipo de dato list_data_t **/
typedef struct list_data        list_data_t;

/** Tipo de dato list_data_ptr_t **/
typedef list_data_t*            list_data_ptr_t;

/** Tipo de dato list_data_t **/
typedef struct list_item_data   list_item_data_t;

/** Tipo de dato list_data_ptr_t **/
typedef list_item_data_t*       list_item_data_ptr_t;

struct list_item_data {
   list_value_t            value;  /** Valor del item actual. **/
   list_item_data_ptr_t    prev;   /** Apuntador al item derecho. **/
   list_item_data_ptr_t    next;   /** Apuntador al item izquierdo. **/
   list_data_ptr_t         list;   /** Apuntador a los datos generales de la lista. **/
};

/** Estructura que guarda la información generalizada de una lista de datos **/
struct list_data {
   list_item_data_ptr_t        first;          /** Primer elemento agregado a la lista **/
   list_item_data_ptr_t        last;           /** Ultimo elemento agregado a la lista **/
   list_size_t                 size;           /** Cantidad de elementos **/
   list_callback_clone_item    clone_item;     /** Apuntador a la función CALLBACK que retornara la copia del valor a asignar **/
   list_callback_release_item  release_item;   /** Apuntador a la función CALLBACK que liberara la copia del valor duplicado en el list_callback_allocator **/
   list_callback_compare_item  compare_item;   /** Apuntador a la función CALLBACK que compara dos elementos de la lista **/
};

...

list_item_t
list_begin(list_t list) {
   if (list_empty(list)) return NULL;
   return (list_item_t)(((list_data_ptr_t)list)->first);
}



Tambien en casos donde provienen de un puntero X y se quiere convertir a un int32_t

Código (c,8,18,42,43,57) [Seleccionar] Expandir



/** Tipo de dato para la estructura AVL **/
typedef void*               avl_t;
typedef avl_t*              avl_ptr_t;

/** Tipo del dato que guarda el valor de un nodo **/
typedef uintptr_t           avl_value_t;
typedef avl_value_t*        avl_value_ptr_t;

typedef size_t              avl_size_t;
typedef avl_size_t*         avl_size_ptr_t;

/** Funcion que retorna el elemento menor de un elemento avl.
* @param value: Nodo del arbol AVL anteriormente creado con avl_allocator(), sirve como pivote.
* @return
*      NULl: No existe o hubo un error.
*/
avl_value_ptr_t avl_getlower(const avl_value_ptr_t value);

/**
* Funcion que busca un elemento (avl_value_t) en un elemento avl (avl_t)
* @param avl: Arbol AVL anteriormente creado con avl_allocator().
* @param value: Elemento a buscar.
* @return Retorna el apuntador al valor guardado.
*      NULL: No existe el valor buscado.
**/
avl_value_ptr_t avl_find(avl_t avl, const avl_value_t value);

/** Funcion que extrae un nodo del elemento avl indicado.
* @param avl: Apuntador a una variable tipo avl_t anteriormente creada con avl_allocator().
* @param value: Elemento que se buscara.
* @return
*      true: Si se extrajo del elemento avl
*      false: No se extrajo ya que no se encontro o el elemento avl esta vacio o se paso un parametro NULL.
*/
bool avl_remove(avl_t avl, const avl_value_ptr_t value);

avl_value_ptr_t avl_getroot(const avl_t avl);
...
       while (!avl_empty(avl)) {
           //Comprobamos la integridad de eliminación con estas dos lineas.
           avl_value_t elim = (avl_value_t)randomnumber(*avl_getlower(avl_getroot(avl)),
                                                        *avl_getupper(avl_getroot(avl)));
           avl_remove(avl, avl_find(avl, elim));
       }

long min(uint32_t a, uint32_t b) {
   return (a<b) ? a:b;
}

void swap(int32_t *a, int32_t *b) {
   *a ^= *b;
   *b ^= *a;
   *a ^= *b;
}

inline int randomnumber(int32_t lower, int32_t upper) {
   if (min(lower, upper) != lower) {
       swap(&lower, &upper);
   }
   return lower + rand() % ((upper + 1) - lower);
}



Uso los list_t como sinónimo de un tipo void* que apunta a una estructura list_data_t, es decir list_t = void* = list_data_ptr_t esto lo hago debido a que estoy creando varias bibliotecas donde las estructuras están dentro de los archivos .c (algunas) y creando varias funciones para el trato de las mismas... aun estoy espesando a creer que esto es una idiotes pero este no es el punto.

El problema radica al momento de compilar con -std=c99 -ansi -wall -pedantic -pedantic-errors

me salta:

Código [Seleccionar] Expandir



/home/blackzerox/Documentos/Programacion/C/CScript/main.c|123|aviso: formato '%d' espera un argumento de tipo 'int', pero el argumento 2 es de tipo 'avl_size_t' [-Wformat]|
/home/blackzerox/Documentos/Programacion/C/CScript/main.c|130|error: el paso del argumento 1 de 'randomnumber' crea un entero desde un puntero sin una conversión|
/home/blackzerox/Documentos/Programacion/C/CScript/main.c|17|nota: se esperaba 'int32_t' pero el argumento es de tipo 'avl_t'|
/home/blackzerox/Documentos/Programacion/C/CScript/main.c|130|error: el paso del argumento 2 de 'randomnumber' crea un entero desde un puntero sin una conversión|
/home/blackzerox/Documentos/Programacion/C/CScript/main.c|17|nota: se esperaba 'int32_t' pero el argumento es de tipo 'avl_t'|
/home/blackzerox/Documentos/Programacion/C/CScript/main.c|144|aviso: formato '%d' espera un argumento de tipo 'int', pero el argumento 2 es de tipo 'avl_size_t' [-Wformat]|
/home/blackzerox/Documentos/Programacion/C/CScript/main.c|147|aviso: formato '%d' espera un argumento de tipo 'int', pero el argumento 2 es de tipo 'avl_size_t' [-Wformat]|
/home/blackzerox/Documentos/Programacion/C/CScript/main.c|160|aviso: formato '%d' espera un argumento de tipo 'int', pero el argumento 2 es de tipo 'avl_size_t' [-Wformat]|
/home/blackzerox/Documentos/Programacion/C/CScript/main.c|173|aviso: formato '%d' espera un argumento de tipo 'int', pero el argumento 2 es de tipo 'avl_size_t' [-Wformat]|
/home/blackzerox/Documentos/Programacion/C/CScript/main.c|189|aviso: formato '%d' espera un argumento de tipo 'int', pero el argumento 2 es de tipo 'avl_size_t' [-Wformat]|
/home/blackzerox/Documentos/Programacion/C/CScript/main.c|192|aviso: formato '%d' espera un argumento de tipo 'int', pero el argumento 2 es de tipo 'avl_size_t' [-Wformat]|
/home/blackzerox/Documentos/Programacion/C/CScript/main.c|228|aviso: formato '%d' espera un argumento de tipo 'int', pero el argumento 2 es de tipo 'map_size_t' [-Wformat]|
/home/blackzerox/Documentos/Programacion/C/CScript/main.c|248|aviso: formato '%d' espera un argumento de tipo 'int', pero el argumento 2 es de tipo 'map_size_t' [-Wformat]|
/home/blackzerox/Documentos/Programacion/C/CScript/main.c|251|aviso: formato '%d' espera un argumento de tipo 'int', pero el argumento 2 es de tipo 'map_size_t' [-Wformat]|
/home/blackzerox/Documentos/Programacion/C/CScript/main.c|264|aviso: formato '%d' espera un argumento de tipo 'int', pero el argumento 2 es de tipo 'map_size_t' [-Wformat]|
/home/blackzerox/Documentos/Programacion/C/CScript/main.c|276|aviso: formato '%d' espera un argumento de tipo 'int', pero el argumento 2 es de tipo 'map_size_t' [-Wformat]|
/home/blackzerox/Documentos/Programacion/C/CScript/main.c|291|aviso: formato '%d' espera un argumento de tipo 'int', pero el argumento 2 es de tipo 'map_size_t' [-Wformat]|
/home/blackzerox/Documentos/Programacion/C/CScript/main.c|293|aviso: formato '%d' espera un argumento de tipo 'int', pero el argumento 2 es de tipo 'map_size_t' [-Wformat]|
/home/blackzerox/Documentos/Programacion/C/CScript/main.c|112|aviso: variable 'value' sin usar [-Wunused-variable]|
||=== Build finished: 19 errors, 0 warnings ===|



Pero claro compilando con -w se arregla todo y compila perfectamente, esto es un problema que apenas vengo captando y solucionando con varios cast pero lo veo muy, no encuentro palabras para esto solo no me agrada.

Código (c) [Seleccionar] Expandir



-------------- Build: Debug in CCScript_Linux ---------------

Compiling: main.c
Compiling: src/CSAVL.c
Compiling: src/CSArray.c
Compiling: src/CSBlockmem.c
Compiling: src/CSByte.c
Compiling: src/CSInfija2PreFija.c
Compiling: src/CSList.c
Compiling: src/CSMap.c
Compiling: src/CSQueue.c
Compiling: src/CSStack.c
Compiling: src/CSString.c
Compiling: src/CSUtiles.c
Compiling: src/CSVector.c
Compiling: src/CScript.c
Linking console executable: bin/Debug/CCScript_Linux
Output size is 30,17 KB
Process terminated with status 0 (0 minutes, 2 seconds)
0 errors, 0 warnings



• ¿En que momentos en necesario realmente usar los cast?.
• ¿Que tan bueno es usar typedef y en que casos (ademas de simplificar)?.
• ¿Es indispensable forzar C99 con -std=c99 -ansi -wall -pedantic -pedantic-errors y por ende obligar los cast?.

Dulces Lunas!¡.

Raro el OpenGL yo lo ocupo en W$, Distribuciones Linux, BlackBerry (En especifico en la Playbook) y quiero ver si funciona en el S.O. de google... pero por lo que veo en mi experiencia OpenGL es muy viable (ocupo características comunes y potables entre plataformas).

Pero puedes usar lo que desees.

Dulces Lunas!¡.