Mensajes

750 es mejor así no expones tu directorio a los demás usuarios. Lo que la gente hace es cambiar el grupo del directorio al grupo que usa tu usuario de apache (www-data por ejemplo). También usan el SETGID al document root, de esa forma todos los archivos que creas acaban siendo parte del grupo de apache (que mientras tengan r-x no deberían tener problemas accediéndolo).

Hay muchas maneras de trabajar los permisos, dependiendo de la situación que estés trabajando.

Si es posible que no funcione porque no estoy desde una PC para probarlo o un hosting y los intérpretes online son un tanto pesados desde un móvil y además algunas veces funcionan de una manera inesperada.

Pero básicamente el código de ejemplo que he dejado es una posible forma que se lo podría hacer.


Saludos

Yo creo que a final de cuentas tu ejemplo es una manera manual para confirmar si es una variable o literal.

E.g.

Código (php) [Seleccionar] Expandir


function test($valor, $estasUsandoVariable){
   if($estasUsandoVariable) {
     echo 'El valor es una variable';
   } else {
     echo 'El valor es una literal';
   }
}

$variable = 700;
test(700, false);
test($variable, true);

Lo cual no contesta la pregunta realmente...

Hola, una manera que se me ocurre tomando tu código de ejemplo, sería la siguiente:

Código (php) [Seleccionar] Expandir



$variable = NULL;
F(700);
$variable = 700;
F($variable);

function F($dato)
{
    if(!is_null($dato))
    {
        echo 'el parametro viene de una variable';
        $variable = NULL;
    }
    else
    {
        echo 'el parametro viene de una constante';
    }
}



Saludos

Este código no funciona.

Dudo mucho que haya una situación en la que importe si el argumento es una literal o una variable. Al menos no en PHP.

Simplemente no tenías agregado los repositorios de código fuente.

Código (bash) [Seleccionar] Expandir


echo "deb-src http://http.kali.org/kali kali-rolling main non-free contrib" | sudo tee -a /etc/apt/sources.list

No, me acaba de dar cuenta que los paquetes están solo para amd64. Creo que puedes compilar los paquetes con apt-get.

Código (bash) [Seleccionar] Expandir


# Desde home
sudo apt-get build-dep libswt-gtk-4-java #instala las dependencias para hacer la build del paquete
sudo apt-get install build-essentials # compiladores y demás

apt-get source libswt-gtk-4-java # descarga el codigo fuente del paquete
# cd <directorio-donde-esta-el-codigo-del-paquete>
dpkg-buildpackage -us -uc #construye el paquete

Y listo deberías tener un .deb para ese paquete que puedes instalar con dpkg. No estoy muy seguro si funcione, tecnicamente las fuentes deberían estar ahí para cualquier arquitectura creo yo... pero igual y no están. Lo cual significa que tienes que compilar manualmente.

¿Intentaste instalar los paquetes que te dice apt?

Código (bash) [Seleccionar] Expandir


sudo apt install libswt-gtk-4-java libswt-cairo-gtk-4-jni

Y después puedes volver a correr el comando:

Código (bash) [Seleccionar] Expandir


sudo dpkg -i ipscan_3.7.6_all.deb

Yo creo que veo esos dos paquetes en el repositorio de kali con 32 bits. Así que debe ser posible...

Pues tendrías que mirar el explain:

Código (sql) [Seleccionar] Expandir


EXPLAIN SELECT `contrato`.`id`, `contrato`.`n_contrato`, `cliente`.`tipoc`, `cliente`.`nombremp`, `cliente`.`nombre` AS cnombre, `cliente`.`apellidos` AS capellidos, `fiador`.`nombre` AS fnombre, `fiador`.`apellidos` AS fapellidos, `promotor`.`nombrecorto` AS prnombrecorto, `promotor`.`nombre` AS prnombre, `promotor`.`apellidos` AS prapellidos, `contrato`.`f_firma`, `contrato`.`f_final`, `contrato`.`f_revicion`, `contrato`.`importe`, `contrato`.`facimporte`, `inmueble`.`nombre` AS inmuebles, `inmueble`.`direccion` AS idireccion, `inmueble`.`id` AS idinmueble, `propietario`.`nombrecorto` AS pnombrecorto, `propietario`.`nombre` AS pnombre, `propietario`.`apellidos` AS papellidos, `documentos`.`ruta_doc`, `documentos`.`iddrive`, `cliente`.`rutap_doc` AS rutac, `fiador`.`rutap_doc` AS rutaf, `propietario`.`rutap_doc` AS rutap, `promotor`.`rutap_doc` AS rutapr, `contrato`.`id_documento`, `contrato`.`id_promotor`, `contrato`.`id_cliente`, `contrato`.`id_fiador`, `contrato`.`vencido`, DATE_FORMAT(f_firma, ' %d-%m-%Y') AS ffirma, DATE_FORMAT(f_final, ' %d-%m-%Y') AS ffinal, DATEDIFF(f_final, CURDATE()) AS dia, DATEDIFF(f_revicion, CURDATE()) AS diar
FROM (`contrato` LEFT JOIN cliente ON contrato.id_cliente = cliente.id LEFT JOIN fiador ON contrato.id_fiador = fiador.id LEFT JOIN promotor ON contrato.id_promotor = promotor.id LEFT JOIN documentos ON contrato.id_documento = documentos.id LEFT JOIN inmueble ON contrato.id_inmueble = inmueble.id LEFT JOIN propietario ON inmueble.id_propietario = propietario.id)
WHERE `vencido` =  '2'
ORDER BY `n_contrato` ASC, `inmuebles` ASC, `f_final` ASC, `f_final` ASC, `importe` ASC
LIMIT 20

Hay un montón de formas de hacer esto. Lo más sencillo es usar nginx de reverse proxy. Y puedes usar:

Código [Seleccionar] Expandir

https://tudominio.com/python

Para usar tu api de python.

O puedes usar:

Código [Seleccionar] Expandir

https://tudominio.com/node

Para usar tu api de node.

Igual y puedes usar node.tudominio.com o python.tudominio.com.

Gracias por la explicación.
Pero yo quiero que busque cadenas de palabras completas y no fragmentos de cadena donde tenga la cadena de busqueda.

Es decir, si tengo

Código [Seleccionar] Expandir


|Patata
|Patata-Frita
|Patata.Frita


Y escribo
SELECT dato FROM datos WHERE dato RLIKE 'patata'

me devolveria los 3 registros porque contienen la palabra patata cuando solo me deberia devolver la primera [patata].
Es decir que busque palabras completas y se considera palabra completa la separada por un espacio.

Ej :
arbol caido  => 2 palabras
arbol.caido => 1 palabra

Espero haberme explicado bien
Gracias



[

Entonces no puedes usar: [[:<:]] ni [[:>:]], porque esos caracteres consideran PATATA-FRITA como dos palabras. Podrías usar:

Código (sql) [Seleccionar] Expandir

"(^|[[:blank:]]+)DEC\\.([[:blank:]]+|$)"

El punto en REGEX es un carácter especial. Debe ser escapado.  Considera esto:

Una base de datos llamada datos, con una sola columna varchar llamada dato. 3 inserts:

Código [Seleccionar] Expandir

|Patata
|Patata-Frita
|Patata.Frita

Código (sql) [Seleccionar] Expandir

SELECT dato FROM datos WHERE dato RLIKE '.'

Esta consulta me devuelve todos los datos porque el punto equivale a cualquier caracter.

Código (sql) [Seleccionar] Expandir

SELECT dato FROM datos WHERE dato RLIKE 'Patata.'

Esta consulta me devuelve Patata-Frita y Patata.Frita porque el punto equivale a cualquier caracter.

Código (sql) [Seleccionar] Expandir

SELECT dato FROM datos WHERE dato RLIKE 'Patata\\.'

Esta consulta me devuelve solo Patata.Frita, porque he escapado el punto.


https://dev.mysql.com/doc/refman/8.0/en/regexp.html#regexp-syntax

Saludos

Aunque escapes el punto, no vas a obtener un match en este caso. Si bien el punto es un carácter que significa cualquier carácter excepto saltos de línea, sin escaparse el punto puede representar el punto literalmente (y los otros caracteres como has puesto). Así que aquí debería poder hacer match a DEC.... (y también DECA, DECB etc).

Yo creo que el problema aquí es con el marcador de final de palabra:

[[:>:]]

En este caso, el delimitador de una palabra está dado por el mismo punto. Lo que significa que el punto nunca llega a ser parte de la palabra. Por lo tanto:

Código (sql) [Seleccionar] Expandir

'[[:<:]]PALABRA[[:>:]]'

PALABRA nunca hará match si incluye un punto (porque el punto es el delimitador que indica el final de la palabra).