Hola Estimados/as. Junto con saludar me gustaría recurrir a su experiencia en inyección de bases de datos sql. Resulta que tengo que impedir que se pueda realizar una inyección SQL en una base de datos SQLite. Me piden ocupar específicamente el uso de prepared
statements.

Ejemplo:

“SELECT * FROM Alumno WHERE rut = ​:rut​"
 

El código que tengo (que funciona por cierto) es:

define("SQLITE_DB_PATH", "navegadorcito.db");
 
$connection = NEW SQLite3(SQLITE_DB_PATH) OR die("No se pudo Conectar con la base de Datos");
 
$sqlStr = "SELECT * FROM Alumno WHERE rut = " . $_GET["rut"];
    echo $sqlStr;
    $connection->query($sqlStr);
    $query = $connection->query($sqlStr);
    while($fila = $query->fetchArray()) {
        print_r($fila);
        echo "<br/>";
    }
 
 

Me imprime por pantalla los datos del rut ingresado por medio del link del navegador. Pero como sabrán los más experimentados, a este código facilmente se le puede poner una inyección sql.

He encontrado código como el siguiente:

 
//CONNECT this creates a NEW PDO object
$db = NEW PDO('sqlite:/path/to/database.sdb');
 
//Build your SQL query WITH parameters :FIELD 
$sql = "SELECT * FROM sometable WHERE someCol=:field";
//PREPARE the above query
$statement = $db->prepare($sql);
//Bind the VALUE received FROM the form OR such WITH the parameter place holder
$statement->bindParam(':field', $_POST['someVal']);
//EXECUTE the prepared query
$statement->execute();
//Fetch the RESULT
$result = $statement->fetchAll(PDO::FETCH_ASSOC);
 
 
//Treat the RESULT AS a pure array
foreach ($result AS $row){
    //do something
}

El cual ocupa el método de prepare statements para evitar la injección SQL en una base de datos SQLite, pero no puedo adaptarlo al código que yo tengo. Cada cambio que le hago me lanza un error por pantalla.

Hasta el momento mi principal duda es qué pongo dentro del PDO en ---new PDO('sqlite:/path/to/database.sdb');---

Si bien la base de datos que ocupo se llama navegadorcito.db, cada vez que pongo ese nombre ahí salta un error al cargar el archivo en el navegador.


Ojala me pudieran dar una mano para entender qué pasa.

Agradecido de antemano por leer esto, me despido.

Hola que tal estimados. Muchas gracias por ingresar a leer esta pregunta que me tiene algo confuso.

Verán, resulta que vi un ejercicio en un certamen en donde se debía eliminar un elemento de un vector y correr los elementos de las otras posiciones para que así no se perdiera espacio.

Ejemplo de lo que digo:

 
public static void main (String []args){
 
		int bus[] = new int [10];
 
		for (int i = 0; i <bus.length-2; i++){
 
			bus[i]=i*2;
		}
 
                bus[0]=1;
 
		System.out.println();
 
	    for (int i = 0; i <bus.length; i++){
 
			System.out.println(bus[i]);
		}
 
	}
 
 
 

El código de arriaba es sumamente burdo. Simplemente llené las posiciones de un vector dejando las ultimas 2 vacías.

Lo que lanza por pantalla es lo siguiente:

1
2
4
6
8
10
12
14
0
0


Mi pregunta es, imaginándome que yo quiero borrar el numero 8 de ese vector, ¿cómo lo borro y muevo los otros números para que el vector aproveche esa posición eliminada?


Estoy practicando para una evaluación de fin de semestre y me topé con este ejercicio en donde te obligan a trabajar con vectores. Espero me puedan ayudar. De antemano muchas gracias!

Hola chicos! que tal les va? espero que bien. Bueno, les cuento, estoy realizando ejercicios del libro silverchatz de Sistemas Operativos para prepararme para mi evaluación de fin de año. En fin, resulta que uno de los ejercicios que hice era crear un programa en C (linux) que ejemplificara una impresora a la cual le iban llegando diversos trabajos (documentos) a una cola de impresión y estos los debe ir imprimiendo según la prioridad que tengan dichos documentos. Bueno el programa ya lo hice, pero me dejó intrigado la pregunta teórica que viene después de realizar el código:

Que consideraciones hay que tomar si existen varias impresoras disponibles?

En el libro no hay solucionario para esta pregunta y en lo personal, no llego a una respuesta que me convenza. me podrían dar su opinión de cual es la respuesta más acertada?

Acá dejo el código en caso de que no se haya atendido lo anterior.

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <errno.h>
#include <pthread.h>
#include <semaphore.h> 
#define Max_Trabajo 60 // El número máximo de hebras Trabajos.
 
 
// Prototipos de funciones...
 
void *Trabajos(void *num);
void *servidor(void *);
void rango_espera(int secs);
 
 
 
//Se definen los semaforos.
//El semaforo colaimpresion pone el limite del numero de Trabajos que se permiten ingresar al cuarto de espera en un tiempo determinado.
sem_t colaimpresion;
// Ocupar_servidor asegura la mutua exclusividad en el acceso al uso del servidor.
sem_t Ocupar_servidor;
// DescansaServidor es usada para permitir que el servidor descanse hasta que llegue el Trabajo.
sem_t DescansaServidor;
// MantenerTrabajo es usada para hacer que el Trabajo espere hasta que el servidor haya imprimido el documento.
sem_t MantenerTrabajo;
// Bandera para la hebra del servidor cuando todos los Trabajos han sido atentidos.
int Todohecho = 0;
int TrabajosEsperandoServidor=0;
int numEspacios=1;
 
int main(int argc, char *argv[])
{
    int i;
    pthread_t btid;
    pthread_t tid[Max_Trabajo];
    int numTrabajos;
    int Numero[Max_Trabajo];
    printf("El &#324;umero maximo de Trabajos es 60. Ingresa el numero de Trabajos.\n");
 
    do{
	    scanf("%d",&numTrabajos);
 
	    if(numTrabajos > Max_Trabajo)printf("El nº de Trabajos debe ser menor a %d, ingrese nº de Trabajos.\n",Max_Trabajo);
 
	   }while(numTrabajos>Max_Trabajo);
 
    if (numTrabajos > Max_Trabajo) {
       printf("El Maximo numero de Trabajos es %d.\n", Max_Trabajo);
       /******system("PAUSE");*****************/
       getchar();
       getchar();
 
       return 0;
    }
    printf("Tenemos un servidor que imprime documentos.\n");
    for (i = 0; i < Max_Trabajo; i++) {
        Numero[i] = i;
    }
    // Se inicializa el semaforo con valores iniciales...
    sem_init(&colaimpresion, 0, numEspacios);
    sem_init(&Ocupar_servidor, 0, 1);
    sem_init(&DescansaServidor, 0, 0);
    sem_init(&MantenerTrabajo, 0, 0);
 
    // Se Crea el servidor.
    pthread_create(&btid, NULL, servidor, NULL);
 
    // Se Crea el Trabajo.
    for (i = 0; i < numTrabajos; i++) {
        pthread_create(&tid[i], NULL, Trabajos, (void *)&Numero[i]);
    }
    // Se juntan las hebras a esperar que las otras terminen.
    for (i = 0; i < numTrabajos; i++) {
        pthread_join(tid[i],NULL);
    }
    // Cuando todos los Trabajos hayan terminado, se elimina la hebra servidor.
    Todohecho = 1;
    sem_post(&DescansaServidor); // Se despierta al servidor en la salida.
    pthread_join(btid,NULL);
    getchar();
    getchar();
    return 0;
}
 
void *Trabajos(void *Numero) {
     int num = *(int *)Numero; // periodo de tiempo aleatorio para llegar.
     printf("hebra %d creada\n", num);
     rango_espera(5);
     if(numEspacios+1==TrabajosEsperandoServidor)printf("Trabajo %d intenta ingresar a la cola de impresion\nEl Trabajo desiste de ingresar a la cola porque hay muchos trabajos\n", num); // Espere hasta que sea prudente ingresar a la cola de impresion...
     sem_wait(&colaimpresion); 
    printf("Trabajo %d intenta ingresar a la cola de impresion \nTrabajo %d entra a la cola de impresion.\n************************************Hay %d Trabajos esperando a ocupar el servidor \n", num, num,++TrabajosEsperandoServidor); // Esperar a que el servidor este libre..
 
     //printf("*****************************************\n");
    // printf("**Hay %d Trabajos en la cola de impresion      **\n",TrabajosEsperandoServidor);
    // printf("*****************************************\n");
     sleep(10);
     sem_wait(&Ocupar_servidor); // Si el servidor está libre entonces un trabajo aprovecha.
     sem_post(&colaimpresion); // Despierta el servidor...
     printf("Trabajo %d ocupa el servidor.\n", num);
     sem_post(&DescansaServidor); // Espera a que el servidor termine de imprimir el trabajo.
     sem_wait(&MantenerTrabajo); // Deja de ocupar el servidor.
     sem_post(&Ocupar_servidor);
   printf("Trabajo %d deja de ocupar el servidor.\n************************************Hay %d Trabajos intentando ocupar el servidor\n", num,--TrabajosEsperandoServidor);
 
    // printf("*****************************************\n");
    // printf("**Hay %d Trabajos en la cola de impresion **\n",TrabajosEsperandoServidor);
     //printf("*****************************************\n");
     sleep(10);
}
 
void *servidor(void *junk)
{
// Mientras todavía hayan Trabajos que atender... El servidor es omniciente y puede decir si hay Trabajos aún en el camino a su tienda.
 
  while (!Todohecho) { // Esperar hasta que alguien llegue y te despierte..
    if( TrabajosEsperandoServidor==0 ) printf("el servidor esta esperando\n");
    sem_wait(&DescansaServidor); // Omitir todo esto al final...
    if (!Todohecho)
    { // Tomar un monto aleatorio de tiempo para imprimir el Trabajo..
     printf("el servidor esta imprimiendo el documento\n");
     rango_espera(3);
     printf("el servidor ha terminado de imprimir el documento.\n"); // Se libera al Trabajo cuando se haya imprimido el documento...
     sem_post(&MantenerTrabajo);
    }
    else {
         printf("El servidor ha terminado con la cola de impresion.\n");
    }
   }
}
 
void rango_espera(int secs) {
     int len = 1; // Se genera un numero arbitrario...
     sleep(len);
}
 
 

Gracias de Antemano!

Que tal chicos. muchas gracias de antemano por darse el tiempo de leer esto. Verán, quiero ejecutar un programa que hice hace 1 año (y que en ese tiempo funcionaba correctamente). Ahora cuando lo intento compilar me salen los siguentes errores (todos por lo visto haciendo referencia a lo mismo):

referencia a "sem_init" sin definir
referencia a "sem_post" sin definir
referencia a "pthread_create" sin definir
referencia a "pthread_join" sin definir
referencia a "sem_wait" sin definir

Esos son. Se repiten varias veces. Soy muy amateur en el tema y no se por qué ahora (en comparación al año pasado) no puedo compilarlo y no se qué debo hacer para ejecutarlo. Por cierto, estoy trabajando en Ubuntu.

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <errno.h>
#include <pthread.h>
#include <semaphore.h> 
#define Max_Clientes 25 // El número máximo de hebras clientes.
 
 
// Prototipos de funciones...
 
void *clientes(void *num);
void *barbero(void *);
void rango_espera(int secs);
 
//Se definen los semaforos.
//El curto_espera pone el limite del numero de clientes que se permiten ingresar al cuarto de espera en un tiempo determinado.
sem_t cuartoespera;
// La SillaBarbero asegura la mutua exclusividad en el acceso a la silla del barbero.
sem_t SillaBarbero;
// AlmohadaBarbero es usada para permitir que el barbero descanse hasta que llegue el cliente.
sem_t AlmohadaBarbero;
// CinturonAsiento es usada para hacer que el cliente espere hasta que el barbero haya cortado su cabello.
sem_t CinturonAsiento;
// Bandera que para la hebra del barbero cuando todos los clientes han sido atentidos.
int Todohecho = 0;
int clientesBarberia=0;
int numSillas;
 
int main(int argc, char *argv[])
{
    int i;
    pthread_t btid;
    pthread_t tid[Max_Clientes];
    int numClientes;
    int Numero[Max_Clientes];
    printf("El &#324;umero maximo de clientes es 25. Ingresa el numero de clientes y sillas.\n");
 
    do{
	    scanf("%d",&numClientes);
	    scanf("%d",&numSillas);
 
	    if(numClientes > Max_Clientes)printf("El nº de clientes debe ser menor a %d, ingrese nº de clientes y sillas nuevamente.\n",Max_Clientes);
 
	   }while(numClientes>Max_Clientes);
 
    if (numClientes > Max_Clientes) {
       printf("El Maximo numero de Clientes es %d.\n", Max_Clientes);
       /******system("PAUSE");*****************/
       getchar();
       getchar();
 
       return 0;
    }
    printf("Una solucion al problema del barbero dormilon usando semaforos.\n");
    for (i = 0; i < Max_Clientes; i++) {
        Numero[i] = i;
    }
    // Se inicializa el semaforo con valores iniciales...
    sem_init(&cuartoespera, 0, numSillas);
    sem_init(&SillaBarbero, 0, 1);
    sem_init(&AlmohadaBarbero, 0, 0);
    sem_init(&CinturonAsiento, 0, 0);
 
    // Se Crea el Barbero.
    pthread_create(&btid, NULL, barbero, NULL);
 
    // Se Crea el Cliente.
    for (i = 0; i < numClientes; i++) {
        pthread_create(&tid[i], NULL, clientes, (void *)&Numero[i]);
    }
    // Se juntan las hebras a esperar que las otras terminen.
    for (i = 0; i < numClientes; i++) {
        pthread_join(tid[i],NULL);
    }
    // Cuando todos los clientes hayan terminado, se elimina la hebra barbero.
    Todohecho = 1;
    sem_post(&AlmohadaBarbero); // Se despierta al barbero en la salida.
    pthread_join(btid,NULL);
    getchar();
    getchar();
    return 0;
}
 
void *clientes(void *Numero) {
     int num = *(int *)Numero; // Sale de la tienda y toma algún periodo de tiempo aleatorio para llegar.
     printf("hebra %d creada\n", num);
     rango_espera(5);
     if(numSillas+1==clientesBarberia)printf("cliente %d llega a la barberia\nEl cliente abandona la barberia porque esta llena\n", num); // Espere hasta que haya espacio para abrir en la sala de espera...
     sem_wait(&cuartoespera); 
    printf("cliente %d llega a la barberia \ncliente %d entra a la sala de espera.\n************************************Hay %d clientes en la barberia \n", num, num,++clientesBarberia); // Esperar a que la silla del barbero este libre..
 
     //printf("*****************************************\n");
    // printf("**Hay %d clientes en la barberia       **\n",clientesBarberia);
    // printf("*****************************************\n");
     sleep(10);
     sem_wait(&SillaBarbero); // Si la silla esta libre entonces abandona su lugar en la sala de espera..
     sem_post(&cuartoespera); // Despierta el Barbero...
     printf("cliente %d llama al barbero.\n", num);
     sem_post(&AlmohadaBarbero); // Espera a que el barbero termine de cortar su pelo.
     sem_wait(&CinturonAsiento); // Deja la silla.
     sem_post(&SillaBarbero);
   printf("cliente %d deja la barberia.\n************************************Hay %d clientes en la barberia\n", num,--clientesBarberia);
 
    // printf("*****************************************\n");
    // printf("**Hay %d clientes en la barberia **\n",clientesBarberia);
     //printf("*****************************************\n");
     sleep(10);
}
 
void *barbero(void *junk)
{
// Mientras todavía hayan clientes que atender... El barbero es omniciente y puede decir si hay clientes aún en el camino a su tienda.
 
  while (!Todohecho) { // Esperar hasta que alguien llegue y te despierte..
    if( clientesBarberia==0 ) printf("el barbero esta jugando\n");
    sem_wait(&AlmohadaBarbero); // Omitir todo esto al final...
    if (!Todohecho)
    { // Tomar un monto aleatorio de tiempo para cortar el cabello del cliente..
     printf("el barbero esta cortando el cabello\n");
     rango_espera(3);
     printf("el barbero ha terminado de cortar el cabello.\n"); // Se libera al cliente cuando ya se le haya cortado el pelo...
     sem_post(&CinturonAsiento);
    }
    else {
         printf("El barbero ha terminado por el dia.\n");
    }
   }
}
 
void rango_espera(int secs) {
     int len = 1; // Se genera un numero arbitrario...
     sleep(len);
}

Esa es mi duda, de antemano muchas gracias!

Hola chicos/as que tal? espero que estén bien. Vine nuevamente aquí porque uds siempre me sacan las dudas precisas que tengo, y debo aclarar que les estoy muy agradecido. Ahora bien necesito que por favor alguien me explique (si es posible con manzanitas o dibujitos xd) por qué ésta función de invertir lista funciona tan bien:

 
typedef struct NODO{
 
	char *nombre;
	struct NODO *sgte;
 
}nodo;
 
void invertirlista(nodo **inicio){
 
	nodo *aux,*next;
 
	aux=*inicio;
	*inicio=NULL;
 
	while(aux!=NULL){
 
		next=aux->sgte;
		aux->sgte=*inicio;
		*inicio=aux;
		aux=next;
 
	}
}

El typedef lo coloqué por si alguien siente necesario saber como fue hecha la lista (aunque verdaderamente no creo que importe para la pregunta que estoy haciendo).Sé como crear,mostrar y eliminar listas y nodos, he intentado esquematizar ésta función tan corta pero no he podido aclararle a mi cabeza como funciona. De antemano muchas gracias por su ayuda  

Que tal chicos y chicas,disculpen la pregunta pero me puse ante los diversos casos en el manejo de structs y éste (que creo que es básico) no lo puedo hacer.

#include <stdio.h>
 
typedef struct humano{
 
	int *trabajos;
 
}persona;
 
int main(){
 
	int cantidad_personas=8;
	int cantidad_trabajos=4;
	persona *primera;
	primera=(persona *)malloc(sizeof(persona)*cantidad_personas);
 
	/* Hasta este punto por lo que entiendo hice un arreglo dinamico en donde
	   ubicamos a la persona en un espacio del arreglo*/
 
	//Ahora bien cada persona tendrá más de un trabajo por lo cual el puntero
	//trabajo (*trabajos) debemos convertirlo en un vector.
 
	return 0;
}

Mi pregunta es ¿cómo hago eso? el *primera que es de tipo persona lo transformamos en un vector dinámico, pero una vez hecho eso ¿Cómo transformo el puntero que ésta dentro de *primera en otro vector?

De antemano muchas gracias.

Hola, disculpen las molestias pero me gustaría saber como se hace esto en lenguaje C:

Tengo 4 puntos que representan dos segmentos en el plano cartesiano y cada uno de estos puntos está definido obviamente por dos coordenadas x e y.

EJ:

R1= (x1,y1) (x2,y2)
R2= (x3,y3) (x4,y4)

Bueno, en si tengo que hacer un programa que me pide muchas cosas, pero ésta parte en especifico (ver si dos segmentos se intercectan o no) no se me ha podido ocurrir. Alguien me puede orientar porfavor?

Mi problema fundamental es como se definen los puntos...

EJ: R1=A ,B (siendo A un punto y B otro)

Y lo que yo debo usar es:

R1=(x1,y1) (x2,y2) [siendo dos variables cartesianas (x e y) un punto, y otros dos el otro punto.

Entonces, como puedo decir que un punto es mayor o menor a otro si ocupo coordenadas cartesianas para definir a cada punto?

Se me ocurrió que x1>x2 && y1>y2, si se cumple entonces el punto (x1,y1) es mayor, y de forma analoga si x1<x2 && y1<y2 entonces el punto (x2,y2 es mayor). Pero que ocurre si por ejemplo x1<x2 && y1>y2? entonces el punto es mayor, menor o que?

Necesito dilucidar eso...


Muchas gracias de antemano por las molestias.