, Détail sur l’adoption de droits sur les programmes

Vous connaissez les programmes en adoption de droit, ce sont des programmes qui s’exécutent avec le droit du propriétaire et non celui du job en cours.

C’est relativement clair sur les accès natifs, mais sur SQL et sur des instructions mixtes c’est pas toujours évident à comprendre

Voici un détail sur les fichiers, on peut agir sur 3 paramètres
un sur la commande de compile ou d’assemblage USRPRF()
2 qui peuvent être fixés par la commande compile ou par les options SQL
EXEC SQL
Set Option
..
UsrPrf = *USER,
DynUsrPrf = *USER,
..
;

On va donc essayer de voir les combinaisons possibles de ces 3 options

Voici notre protocole un programme sqlrpgle et une table en *exclude et la convention *SYS

**free
ctl-opt DFTACTGRP(*NO) ;
//
// CREATE TABLE GDATA/ATSTADOPT (CODE DEC (6 , 0) NOT NULL WITH
// DEFAULT, TEXT CHAR (30 ) NOT NULL WITH DEFAULT)
// droit public *exclude
//
dcl-f
ATSTADOPT
USAGE(*UPDATE:*OUTPUT) usropn
rename(ATSTADOPT:ATSTADOPF) ;
dcl-s sqldta char(100);
//
// Option SQL
//
EXEC SQL
Set Option
Naming = *Sys,
Commit = *None,
UsrPrf = *Owner, // ici
DynUsrPrf = *Owner, // ici
Datfmt = *iso,
CloSqlCsr = *EndMod;
// accès natif
// 2 instructions Lecture + Maj
open(e) atstadopt ;
if not %error() ;
read(e) atstadopt ;
if not %error() ;
dsply (%char(%status) + ‘ accès natif ok’) ;
code = 2 ;
update(e) ATSTADOPF ;
else ;
dsply (%char(%status) + ‘ accès natif ko’) ;
endif ;
else ;
dsply (%char(%status) + ‘ ouverture native ko’) ;
endif ;
//
// sql statique
//
exec sql
UPDATE ATSTADOPT SET CODE = 3 ;
if sqlcode <> 0;
dsply (%char(sqlcode) + ‘ SQL statique ko’) ;
else ;
dsply (%char(sqlcode) + ‘ SQL statique ok’) ;
endif ;
//
// sql dynamique
//
sqldta = ‘UPDATE ATSTADOPT SET CODE = 4’ ;
EXEC SQL EXECUTE IMMEDIATE :SQLDTA ;
if sqlcode <> 0;
dsply (%char(sqlcode) + ‘ SQL dynamique ko’) ;
else ;
dsply (%char(sqlcode) + ‘ SQL dynamique ok’) ;
endif ;
Return ;

Test 1

USRPRF(*user)
UsrPrf = *User,
DynUsrPrf = *User,

call atstadopt

Opération non autorisée sur fichier ATSTADOPT de *LIBL, membre, ou unité
*N.
DSPLY 1217 ouverture native ko
Non autorisé à l’objet ATSTADOPT de GDATA type *FILE.
Non autorisé à l’objet ATSTADOPT dans GDATA, de type *FILE.
DSPLY -551 SQL statique ko
Non autorisé à l’objet ATSTADOPT de GDATA type *FILE.
Non autorisé à l’objet ATSTADOPT dans GDATA, de type *FILE.
DSPLY -551 SQL dynamique ko

Test 2

USRPRF(*owner)
UsrPrf = *User,
DynUsrPrf = *User,

call atstadopt
DSPLY 0 accès natif ok
DSPLY 0 SQL statique ok
Non autorisé à l’objet ATSTADOPT de GDATA type *FILE.
Non autorisé à l’objet ATSTADOPT dans GDATA, de type *FILE.
DSPLY -551 SQL dynamique ko

Test 3

USRPRF(*owner)
UsrPrf = *OWNER,
DynUsrPrf = *OWNER,

call atstadopt
DSPLY 0 accès natif ok
DSPLY 0 SQL statique ok
DSPLY 0 SQL dynamique ok

Test 4

USRPRF(*USER)
UsrPrf = *OWNER,
DynUsrPrf = *USER,

call atstadopt
Opération non autorisée sur fichier ATSTADOPT de *LIBL, membre, ou unité
*N.
DSPLY 1217 ouverture native ko
Non autorisé à l’objet ATSTADOPT de GDATA type *FILE.
Non autorisé à l’objet ATSTADOPT dans GDATA, de type *FILE.
DSPLY -551 SQL statique ko
Non autorisé à l’objet ATSTADOPT de GDATA type *FILE.
Non autorisé à l’objet ATSTADOPT dans GDATA, de type *FILE.
DSPLY -551 SQL dynamique ko

Test 5

USRPRF(*USER)
UsrPrf = *OWNER,
DynUsrPrf = *OWNER,
call atstadopt

Opération non autorisée sur fichier ATSTADOPT de *LIBL, membre, ou unité
*N.
DSPLY 1217 ouverture native ko
Non autorisé à l’objet ATSTADOPT de GDATA type *FILE.
Non autorisé à l’objet ATSTADOPT dans GDATA, de type *FILE.
DSPLY -551 SQL statique ko
Non autorisé à l’objet ATSTADOPT de GDATA type *FILE.
Non autorisé à l’objet ATSTADOPT dans GDATA, de type *FILE.
DSPLY -551 SQL dynamique ko

Remarques

2 petites particularités sur

1) sur Usrprf SQL

*NAMING (la valeur par défaut)
Le profil utilisateur est déterminé par la convention d’appellation. S’il s’agit de la convention *SQL,
USRPRF(*OWNER) est utilisé. S’il s’agit de la convention *SYS, USRPRF(*USER) est utilisé.

2) Option SQL souvent inutile

Si vous n’êtes pas en adoption de droit sur le programme
UsrPrf et DynUsrPrf sont sans effet

Si le programme est en adoption de droit
UsrPrf = *OWNER est implicite
à l’inverse de DynUsrPrf qui doit être à *OWNER pour fonctionner

Une petite requête pour analyser une bibliothèque :

// liste des programmes avec les users d’exécution d’une bibliothèque
SELECT A.PROGRAM_SCHEMA,
a.PROGRAM_NAME,
a.PROGRAM_TYPE,
IFNULL(a.NAMING, ‘*NOSQL’) AS convention,
a.PROGRAM_OWNER,
b.user_profile AS user_program,
IFNULL(A.USER_PROFILE, ‘*NOSQL’) AS user_static,
IFNULL(A.DYNAMIC_USER_PROFILE, ‘*NOSQL’) AS usre_dynamic
FROM qsys2.sysprogramstat a
JOIN QSYS2.PROGRAM_INFO b
ON a.PROGRAM_SCHEMA = b.Program_library
AND a.PROGRAM_NAME = b.PROGRAM_NAME
where A.PROGRAM_SCHEMA = ‘votre bib’;

, , Changer le groupe d’activation d’un programme

Vous voulez changer le groupe d’activation d’un programme. Contrairement à une idée reçue, on peut dans certains cas renommer le groupe d’activation d’un programme ILE

Si vous créez un programme

CRTPGM

Ou 

CRTBNDRPG

Vous allez indiquer le groupe d’activation d’exécution de votre programme

Vous ne pouvez pas changer le groupe d’activation par CHGPGM !

Mais vous pouvez le faire par la commande UPDPGM 

avant ==> DSPPGM AATSTRET

Attribut du groupe d’activation  . . . . . . . :   PLB1

UPDPGM PGM(AATSTRET) MODULE(*NONE) ACTGRP(PLB45)              
Valeurs des paramètres AUT et USRPRF ignorées.                
L’objet remplacé AATSTRET type *PGM a été déplacé dans QRPLOBJ.
Programme AATSTRET créé dans la bibliothèque GDATA.            
Programme AATSTRET mis à jour dans GDATA.   

après  ==>DSPPGM AATSTRET

Attribut du groupe d’activation  . . . . . . . :   PLB45                   

la seule limitation est que le groupe doit être nommé

Pour interdir ce changement à l’assemblage vous devez indiquer

CRTPGM …  ALWUPD(*NO) 

PS :    

Cette option n’existe pas sur le CRTBNDRPG donc modifiable par défaut 

Vous devez avoir le droit *change sur programme.

Rappel:

En batch on essaye d’avoir le premier programme qui crée le groupe d’activation et les programmes appelés s’exécuteront en *caller

Dans les autres cas, webservice, interactif, etc il peut être préférable d’avoir un groupe d’activation par programme

Pour analyser les groupes actifs, vous pouvez utiliser le service : QSYS2.ACTIVATION_GROUP_INFO

— Liste des groupes par Travail
SELECT A.JOB_NAME,
       count(*)
    FROM TABLE (
             QSYS2.ACTIVE_JOB_INFO()
         ) AS A
         LEFT JOIN TABLE (
                 QSYS2.ACTIVATION_GROUP_INFO(JOB_NAME => A.JOB_NAME)
             ) AS G
             ON 1 = 1
    group by A.JOB_NAME         
        ORDER BY count(*) desc
            ;

, Retour d’expérience installation IBM i 7.6

En bons élèves, nous profitons de l’été pour faire nos devoirs de vacances. Entre autre, installation de la version 7.6 sur plusieurs de nos partitions.

D’abord une partition de test, bac à sable, puis nos partitions de production i(vous avez peut être vu une interruption de service sur nos sites web).

J’en profite pour faire un petit retour d’expérience sur ces installations.

Et pour finir ce préambule, je remercie l’équipe du support !

Une mise à jour comme les autres ?

Oui, je ne détaille pas ici le processus de mise à jour, c’est classique : téléchargement des images et clés sur ESS, PRUV pour les contrôle etc …

Quelques points d’attention

  • DST/SST
    • Le mot de passe de QSECOFR ne doit pas être celui par défaut (sinon il sera inutilisable)
    • Les profils 11111111 et 22222222 sont supprimés pendant l’installation
    • Bonne pratique : créer au moins un autre profil avec tous les droits pour DST, changer le mot de passe de QSECOFR. Les profils 11111111 et 22222222 ne devraient déjà plus être utilisés depuis longtemps
  • Java 11 64 bit non supporté

Ce qui nous a échappé

Deux sujets qui m’ont mobilisés !

Impossible de saisir le mot de passe de QSECOFR au démarrage

Après l’installation de la 7.6 sur la partition, et fort satisfait, je tentes de me loguer avec QSECOFR : informations d’authentification incorrectes !

Après vérification dans mon gestionnaire de mots de passe, nouvelle tentative : idem.

A la 3ème, profil désactivé …

Heureusement, j’ai toujours un profil clone de QSECOFR pour remédier à ces situations : je change le mot de passe de QSECOFR, et là cela fonctionne !

Le problème est connu et nécessite d’appliquer la PTF SJ05805 (cf https://www.ibm.com/mysupport/s/defect/aCIgJ0000000lGfWAI/dt438834?language=fr). Les mots de passe sont testés en CCSID 37 par le système au lieu du CCSID du travail (émulateur). C’est principalement le caractère « ! » qui pose problème.

Bonne pratique : changer le mot de passe de QSECOFR avant la migration pour un mot de passe simple (quitte à déroger aux règles le temps de l’installation).

Problème de connexion sur tous les serveurs hôtes en TLS

Après installation de la 7.6, impossible de se connecter en telnet sécurisé, ni aux autres services

Et effectivement, le mémo to user (cf https://www.ibm.com/docs/en/ssw_ibm_i_76/pdf/rzaq9.pdf) indique bien :

Dans DCM, allez dans le magasin *SYSTEM, puis gérer « Manage Applications Definitions », sélectionner l’application QIBM_QZBS_SVR_HOSTCNN et associez un certificat (en général le même pour l’ensemble des serveurs hôtes) :

Dès validation la connexion TLS fonctionne, pas besoin d’arrêter/redémarrer des services.

Ce fonctionnement est nécessaire pour la mise en œuvre du MFA, mais impact les services existants.

Tous les systèmes étant sécurisés depuis de nombreuses années, vous devriez être impacté …

En synthèse

A noter que l’ensemble des éléments est bien documenté, y compris les « détails » qui nous ont posés quelques soucis (exception du mot de passe non reconnu).

Une bonne préparation permet de réaliser une migration maitrisée, l’installation elle-même se déroule très bien et rapidement.

, , Les profils _NC en V7R6

En V7R6 vous avez de nouveaux profils qui apparaissent avec l’extention _NC

QPGMR_NC
QSECOFR_NC
QSYSOPR_NC
QUSER_NC

C’est des profils qui ne sont pas modifiables, et ils n’ont pas de mot de passe

Et certains services ibm démarrent avec ceux ci

Conclusions :
Attention, par exemple, si vous avez customisé QUSER ou QPGMR vous pouvez avoir des surprises après migration

QIBM_RUN_UNDER_USER_NO_AUTH

Avec la version V7R6, une nouvelle fonction usage est disponible, elle sert à éviter les soumissions pour un autre profil, paramétre USER( ) dans un SBMJOB,

Même si vous êtes autorisé au profil, vous ne pourrez pas soumettre pour lui

exemple :

Avant

Paramétrage

Sous navigator for i

Après

Conclusions :

Sur certains profils sensibles vous pouvez interdire leurs usage dans un SBMJOB , même pour des utilisateurs *ALLOBJ par exemple

Grand merci à Nathanael pour la mise à disposition de cette V7R6

, , , Clé, contrainte et index : quelles différences ?

Dans une base de données bien définie, nos enregistrements sont identifiés par des clés (ie unique). Il existe toutefois différentes façon de matérialiser ces clés en SQL.

Première bonne résolution : on ne parlera pas ici des DDS (PF/LF) !

Quelques rappels

je n’insiste pas, mais une base de donnée relationnelle, DB2 for i dans notre cas, fonctionne à la perfection, à condition de pouvoir identifier nos enregistrements par des clés.

Cf https://fr.wikipedia.org/wiki/Forme_normale_(bases_de_donn%C3%A9es_relationnelles)

Une normalisation raisonnable pour une application de gestion est la forme normale de Boyce-Codd (dérivée de la 3ème FN).

Clés

Vous pouvez implémenter vos clés de différentes façons, voici une synthèse :

TypeSupport valeur nulle ?Support doublon ?Commentaire
Contrainte de clé primaireTableNonNonValeur nulle non admise, même si la colonne clé le supporte
Contrainte d’unicitéTableOuinon : valeurs non nulles
oui : valeurs nulles
Gère des clés uniques uniquement si non nulles
Index uniqueIndexOuiNonGère des clés uniques.
La valeur NULL est supportée pour 1 unique occurrence
Index unique where not nullIndexOuisnon : valeurs non nulles
oui : valeurs nulles
Gère des clés uniques uniquement si non nulles

Attention donc à la définition de UNIQUE : à priori ce qui n’est pas NULL est UNIQUE.

Concrètement ?

Prenons un cas de test simpliste pour montrer la mécanique : un fichier article avec une clé et un libellé

Clé primaire

La colonne CODE admet des valeurs nulles, mais est fait l’objet de la contrainte de clé primaire.

A la création de la contrainte de clé primaire, le système créé automatiquement une contrainte de type CHECK pour interdire l’utilisation de valeur nulle dans cette colonne :

Avec :

La clé primaire joue son rôle avec des valeurs non nulles :

Et des valeurs nulles :

On retrouve ici le nom de la contrainte générée automatiquement !

Avec une contrainte de clé unique ?

Le comportement est identique sur une clé non nulle.

Mais avec une clé nulle (ou dont une partie est nulle si elle composée) :

On peut ajouter un index unique pour gérer le problème. Dans ce cas, une et une seule valeur nulle sera acceptée :

Mais dans ce cas pourquoi ne pas utiliser une clé primaire ??

Clé étrangère, jointure

Ajoutons un fichier des commandes, ici une simplification extrême : 1 commande = 1 article.

On ajoute une contrainte de clé étrangère qui matérialise la relation entre les tables commande et article. Pour cette contrainte commande_FK, il doit exister une contrainte de clé primaire ou de clé unique sur la colonne CODE dans la table article.

La contrainte se déclenche si l’article référencé n’existe pas :

Cas identique mais en s’appuyant sur la table article_unique qui dispose d’une clé unique et non primaire :

Dans ce cas les valeurs nulles sont supportées, en multiples occurrences (sauf à ajouter encore une fois un index unique au niveau de la commande).

Récapitulons ici nos données pour comprendre les jointures :

Démarrons par ARTICLE & COMMANDE :

La table ARTICLE ne peut pas avoir de clé nulle, donc pas d’ambiguïté ici

Avec right join ou full outer join nous accèderons au lignes de commande pour lesquelles CODE = null.

C’est le comportement attendu.

Voyons avec ARTICLE_UNIQUE et COMMANDE :

Ici on pourrait s’attendre à obtenir également les lignes 11 et 12 de la table COMMANDE : le CODE est nulle pour celles-ci, mais il existe une ligne d’ARTICLE pour laquelle le code est null. Il devrait donc y avoir égalité.

En réalité les jointures ne fonctionnent qu’avec des valeurs non nulles

De même que la clause WHERE :

Il faut donc utiliser ce style de syntaxe :

C’est à dire :

  • soit remplacer les valeurs nulles par des valeurs inexistantes dans les données réelles
  • soit explicitement indiquer la condition de nullité conjointe

Bref, syntaxiquement cela va rapidement se complexifier dans des requêtes plus évoluées.

Clé composée

Evidemment, c’est pire ! Imaginons que l’on ait une clé primaire/unique dans la table ARTICLE composée de 2 colonnes (CODE1, CODE2), et donc présentes toutes les deux dans la table COMMANDE :

Et les performances ?

En utilisant la jointure, l’optimiseur est capable de prendre en charge des accès par index :

Mais en utilisant IFNULL/COALESCE, ces valeurs deviennent des valeurs calculées, ce qui invalide l’usage des index :

Ce n’est donc pas viable sur des volumes plus importants. Il existe des solutions (index dérivés par exemple) mais la mécanique se complique encore !

Préconisations

De façon générale pour vos données de gestion, en excluant les fichier de travail (QTEMP a d’autres propriétés), les fichiers de logs, les fichier d’import/export …

  • Pas de valeur NULL dans vos clés
    • Pour les clés atomique c’est une évidence, pour les clés composées c’est beaucoup plus simple
  • Une contrainte de clé primaire pour toutes vos tables !
    • N’hésitez pas à utiliser des clés auto-incrémentées
  • Des contraintes d’unicités ou des index uniques pour vos autres contraintes d’unicité, techniques ou fonctionnelles
    • Pas d’excès, sinon il y a un défaut de conception (cf les formes normales)
  • Si possible des contraintes de clé étrangère pour matérialiser les relations entre les tables
    • Délicat sur l’existant, les traitements doivent tenir compte du sens de la relation
  • Favorisez l’usage des clés, contraintes et index par l’optimiseur
    • Scalabilité entre vos environnements de développement/test et la production
, , , Gérer vos listes de validation avec SQL !

Vous connaissez bien désormais les services SQL qui vous permettent d’administrer de plus en plus facilement votre IBM i.

IBM fournit des services pour gérer les listes de validation :

Mais rien pour faire la liste des entrées, comme on peut trouver dans l’administration HTTP par exemple.

Nous vous proposons donc une fonction table SQL permettant d’avoir l’intégralité de la gestion via DB2 : cf https://github.com/FrenchIBMi/Outils/tree/master/Validation%20List

Cela permet de revenir sur le principe de l’implémentation via du code RPG :

  • Le code est basé sur les APIs QsyFindFirstValidationLstEntry et QsyFindNextValidationLstEntry
  • Le moteur DB2 appelle l’implémentation :
    • 1 appel initial
    • 1 appel par poste de liste à retourner
    • 1 appel final

Nous utilisons __errno pour retrouver les codes erreur de l’APIs. Les différentes valeurs sont déclarées sous forme de constante.

La fonction SQL retourne les SQL STATE suivants :

  • 02000 lorsque l’on attend la fin des données (fin normale)
  • 38999 pour les erreurs. Cette valeur est arbitraire

Si possible, nous retrouvons le libellé de l’erreur retournée par l’API via strerror et on le retourne à DB2.

Code RPG :

**free

// Compilation / liage :
// CRTRPGMOD MODULE(NB/VLDLUDTF) SRCFILE(NB/QRPGLESRC) 
//           OPTION(*EVENTF) DBGVIEW(*SOURCE)
// CRTSRVPGM SRVPGM(NB/VLDLUDTF) EXPORT(*ALL) ACTGRP(*CALLER)

// Implémentation de la fonction UDTF VALIDATION_LIST_ENTRIES
// Liste les entrées d'une liste de validation
// Utilise l'API QsyFindFirstValidationLstEntry et QsyFindNextValidationLstEntry

// @todo :
// - ajouter le support de la conversion de CCSID
// - améliorer la gestion des erreurs


ctl-opt nomain option(*srcstmt : *nodebugio) ;


// Déclarations pour APIs : QsyFindFirstValidationLstEntry et QsyFindNextValidationLstEntry

dcl-ds Qsy_Qual_Name_T qualified template ;
  name char(10) inz ;
  lib  char(10) inz ;
end-ds ;

dcl-ds Qsy_Entry_ID_Info_T qualified template ;
  Entry_ID_Len int(10) inz ;
  Entry_ID_CCSID uns(10) inz ;
  Entry_ID    char(100) inz ;
end-ds ;

dcl-ds Qsy_Rtn_Vld_Lst_Ent_T qualified template ;
  dcl-ds Entry_ID_Info likeds( Qsy_Entry_ID_Info_T) inz ;

  dcl-ds Encr_Data_Info ;
    Encr_Data_len   int(10) inz;
    Encr_Data_CCSID uns(10) inz;
    Encr_Data       char(600) inz ;
  end-ds ;

  dcl-ds Entry_Data_Info  ;
    Entry_Data_len   int(10) ;
    Entry_Data_CCSID uns(10) ;
    Entry_Data       char(1000) ;
  end-ds ;

  Reserved          char(4) inz ;
  Entry_More_Info   char(100) inz ;
end-ds ;

dcl-pr QsyFindFirstValidationLstEntry int(10) extproc('QsyFindFirstValidationLstEntry');
  vldList       likeds(Qsy_Qual_Name_T) const ;
  vldListEntry  likeds(Qsy_Rtn_Vld_Lst_Ent_T) ;
end-pr ;

dcl-pr QsyFindNextValidationLstEntry int(10) extproc('QsyFindNextValidationLstEntry');
  vldList       likeds(Qsy_Qual_Name_T) const ;
  entryIdInfo   likeds(Qsy_Entry_ID_Info_T)   ;
  vldListEntry  likeds(Qsy_Rtn_Vld_Lst_Ent_T) ;
end-pr ;

// Retrouver le code erreur de l'API
dcl-pr getErrNo int(10) ;
end-pr ;
// Code erreur
dcl-c EACCES   3401 ;
dcl-c EAGAIN   3406 ;
dcl-c EDAMAGE  3484 ;
dcl-c EINVAL   3021 ;
dcl-c ENOENT   3025 ;
dcl-c ENOREC   3026 ;
dcl-c EUNKNOWN 3474 ;

// Retrouver le libellé du code erreur
dcl-pr strError pointer extproc(*CWIDEN : 'strerror') ;
  errNo int(10) value ;
end-pr ;

// gestion UDTF
dcl-c CALL_OPEN     -1;
dcl-c CALL_FETCH     0;
dcl-c CALL_CLOSE     1;
dcl-c PARM_NULL     -1;
dcl-c PARM_NOTNULL   0;


// Liste les entrées de la liste de validation
// ==========================================================================
dcl-proc vldl_list export ;

// Déclarations globales
  dcl-s  ret int(10) inz ;
  dcl-s  errno int(10) inz ;
  dcl-ds vldListEntry likeds(Qsy_Rtn_Vld_Lst_Ent_T) inz static ;
  dcl-ds vldlname  likeds(Qsy_Qual_Name_T) inz          static ;
  dcl-s  first ind inz(*on)                             static ;


  dcl-pi *n ;
    // input parms
    pvldl_lib  varchar(10) const ;
    pvldl_name varchar(10) const ;
    // output columns
    pEntry_ID    varchar(100) ;
    pEntry_Data  varchar(1000) ;
    // null indicators
    pvldl_lib_n    int(5) const ;
    pvldl_name_n   int(5) const ;
    pEntry_ID_n    int(5)       ;
    pEntry_Data_n  int(5)       ;
    // db2sql
    pstate    char(5);
    pFunction varchar(517) const;
    pSpecific varchar(128) const;
    perrorMsg varchar(1000);
    pCallType int(10) const;
  end-pi ;


// Paramètres en entrée
  if pvldl_name_n = PARM_NULL or pvldl_lib_n = PARM_NULL;
    pstate = '38999' ;
    perrorMsg = 'VALIDATION_LIST_LIBRARY ou VALIDATION_LIST_NAME est null' ;
    return ;
  endif ;

  select;
    when ( pCallType = CALL_OPEN );
    // appel initial : initialisation des variables statiques
      vldlname.name = pvldl_name ;
      vldlname.Lib  = pvldl_lib ;
      clear vldListEntry ;
      first = *on ;

    when ( pCallType = CALL_FETCH );
    // retrouver l'entrée suivante
      exsr doFetch ;

    when ( pCallType = CALL_CLOSE );
    // rien à faire

  endsl;


  // traitement de l'entrée suivante
  begsr doFetch ;
    if first ;
      ret = QsyFindFirstValidationLstEntry( vldlname : vldListEntry);
      first = *off ;
    else ;
      ret = QsyFindNextValidationLstEntry( vldlname :
                                           vldListEntry.Entry_ID_Info : vldListEntry);
    endif ;

    if ret = 0 ;
      // Entrée trouvée
      monitor ;
        pEntry_ID   = %left(vldListEntry.Entry_ID_Info.Entry_ID :
                          vldListEntry.Entry_ID_Info.Entry_ID_Len);
        pEntry_Data = %left(vldListEntry.Entry_Data_Info.Entry_Data :
                          vldListEntry.Entry_Data_Info.Entry_Data_len) ;
        pEntry_ID_n   = PARM_NOTNULL ;
        pEntry_Data_n = PARM_NOTNULL ;
      on-error ;
        // Erreur de conversion
        pstate = '38999' ;
        perrorMsg = 'Erreur de conversion' ;
      endmon ;
    else ;
      // Entrée non trouvée : erreur ou fin de lecture
      errno = getErrNo() ;
      select ;
        when errno in %list( ENOENT : ENOREC ) ; // fin de lecture
          pstate = '02000' ;
          return ;
        other ; // Erreur
          pstate = '38999' ;
          perrorMsg = %str(strError(errno)) ;
      endsl ;
    endif ;
  endsr ;

end-proc ;



// Retrouver le code erreur de l'API
dcl-proc getErrNo ;

  dcl-pr getErrNoPtr pointer ExtProc('__errno') ;
  end-pr ;

  dcl-pi *n int(10) ;
  end-pi;

  dcl-s errNo int(10) based(errNoPtr) ;

  errNoPtr = getErrNoPtr() ;
  return errNo ;

end-proc;

Code SQL :

set current schema = NB ;
set path = 'NB' ;

Create or replace Function VALIDATION_LIST_ENTRIES ( 
                  VALIDATION_LIST_LIBRARY  varchar(10),
                  VALIDATION_LIST_NAME     varchar(10) )
               Returns Table                    
               (                   
                 VALIDATION_USER   varchar(100),                   
                 ENTRY_DATA        varchar(1000)
               )                
               external name 'VLDLUDTF(VLDL_LIST)'                
               language rpgle                
               parameter style db2sql                
               no sql                
               not deterministic                
               disallow parallel;


cl: DLTVLDL VLDL(NB/DEMO) ;
cl: CRTVLDL VLDL(NB/DEMO) TEXT('Démo VALIDATION_LIST_ENTRIES')   ;

VALUES SYSTOOLS.ERRNO_INFO(SYSTOOLS.ADD_VALIDATION_LIST_ENTRY(
                             VALIDATION_LIST_LIBRARY => 'NB', 
                             VALIDATION_LIST_NAME    => 'DEMO',
                             VALIDATION_USER         => 'user 1',
                             PASSWORD                => 'MDP user 1',
                             ENTRY_DATA              => 'Client 1'));
VALUES SYSTOOLS.ERRNO_INFO(SYSTOOLS.ADD_VALIDATION_LIST_ENTRY(
                             VALIDATION_LIST_LIBRARY => 'NB', 
                             VALIDATION_LIST_NAME    => 'DEMO',
                             VALIDATION_USER         => 'user 2',
                             PASSWORD                => 'MDP user 2',
                             ENTRY_DATA              => 'Client 1'));
VALUES SYSTOOLS.ERRNO_INFO(SYSTOOLS.ADD_VALIDATION_LIST_ENTRY(
                             VALIDATION_LIST_LIBRARY => 'NB', 
                             VALIDATION_LIST_NAME    => 'DEMO',
                             VALIDATION_USER         => 'user 3',
                             PASSWORD                => 'MDP user 3',
                             ENTRY_DATA              => 'Client 2'));

select * from table(VALIDATION_LIST_ENTRIES( VALIDATION_LIST_LIBRARY => 'NB',
                                             VALIDATION_LIST_NAME    => 'DEMO' )) ;

Cela produit :

Libre à vous maintenant d’utiliser ce résultat pour jointer avec vos fichiers de log HTTP (autorisation basique sur une liste de validation par exemple), avec le service USER_INFO_BASIC, croiser les profils présents dans vos différentes listes …

, , Fonction usage / Exit programme

Vous êtes de plus en plus confronter à la mise en place de sécurité sur des services (ODBC, FTP, etc..)
il existe 2 solutions sur l’ibmi qui vont vous aider dans votre démarche

Les fonctions usage et les exit programmes

Vous avez des interfaces 5250 pour les administrer, mais aussi maintenant Navigator for i
WRKFCNUSG et WRKREGINF
Vous avez également des services SQL
QSYS2.SQL_CHECK_FUNCTION_USAGE(), QSYS2.FUNCTION_USAGE, QSYS2.FUNCTION_INFO
QSYS2.EXIT_POINT_INFO,QSYS2.EXIT_PROGRAM_INFO

Rapidement voici une petite comparaison

D’abord un essai de comparaison entre les principales valeurs

Accès / FonctionnalitéFonction d’usage (Function Usage ID)Programme d’exit (Exit Point)Description / Concerne
Accès base de données (ODBC, JDBC…)QIBM_DB_OPENQIBM_QZDA_INIT, QIBM_QZDA_NDB1Autorise/refuse l’ouverture de base de données (SQL, ODBC, etc.)
SQL Server Mode (QSQSRVR)QIBM_DB_QSQSRVRN/AContrôle l’accès aux jobs QSQSRVR (SQL server mode)
DDM/DRDAQIBM_DB_DDMDRDAQIBM_QDDMDRDASERVER, QIBM_QDDSQLDRDAAccès aux bases via DDM / DRDA
ODBC SpécifiqueN/AQIBM_QZDA_SQL1, QIBM_QZDA_INITAppels SQL via ODBC / DRDA
JDBCN/AQIBM_QZDA_SQL1, QIBM_QZDA_INITJDBC via Toolbox ou Native JDBC
FTPQIBM_FTP_SERVERQIBM_QTMF_SVR_LOGON, QIBM_QTMF_SVR_EXITContrôle l’accès FTP
TelnetQIBM_TELNET_SERVERQIBM_QTV_TELNETContrôle l’accès Telnet
Remote Command (RUNRMTCMD)QIBM_NETWORK_SERVERQIBM_QZRC_RMTExécution de commandes distantes
Client Access (iSeries Access, ACS…)QIBM_ACCESS3270, QIBM_DB_OPENQIBM_QZDA_* (exits ODBC), QIBM_QZRC_RMTAccès via IBM i Access clients (ODBC, FTP, etc.)

Fonctions d’usage (Function Usage) :
Elles permettent d’activer ou de restreindre une fonctionnalité par utilisateur (sans programmation).
Elles ont un mode par défaut ouvert ou fermé
Vous devez ensuite gérer les exceptions à cette règle
C’est en œuvre par défaut sur votre système
C’est dynamique vous pouvez par exemple avoir un scripte qui modifie le paramétrage pour les heures HNO
C’est compliquer pour tracer les refus

Exit Programs (Programmes d’exit) :
Permettent une personnalisation des contrôles d’accès .
Vous pouvez indiquer des critères d’actions, de ressources, de temporalité
exemple, Michel à droit à uniquement le bibliothèque compta en HNO
Vous maitrisez entièrement la logique de contrôle
Vous pouvez auditer ou loguer avant d’interdire par exemple
Vous pouvez impacter les performances de votre système avec un mauvais programme, voir même bloquer sur un plantage
Ce n’est pas en œuvre par défaut sur votre système
Ce n’est pas dynamique vous devrez arrêter le service concerné pour une prise en compte
Simple pour tracer les refus, c’est votre programme

Conclusion
J’espère que ca vous aidera à faire votre choix
dans tous les cas c’est absolument indispensable aujourd’hui de se préoccuper de ces problèmes à minima des accès ODBC

Toujours d’actualité un service qui n’est pas utilisé doit être arrêter

Quand vous passez de FTP à SFTP vous ne bénéficier plus de ces 2 options

, , Les tentatives de connexion échouées

Si vous avez mis en œuvre le journal vous pouvez et même devez analyser les refus de connexion.
Le plus souvent c’est un mauvais mot de passe mais ca peut être aussi une attaque, ou un comportement douteux

Voici une requête simple qui permet cette analyse rapide

SELECT JOB_NAME, USER_NAME, FUNCTION, MESSAGE_ID, MESSAGE_TIMESTAMP
FROM TABLE(QSYS2.DISPLAY_JOURNAL(‘QSYS’, ‘QAUDJRN’))
WHERE MESSAGE_ID IN (‘CPF2234’, ‘CPF1107’, ‘CPF1393’)
ORDER BY MESSAGE_TIMESTAMP DESC;

Les messages traités ici
CPF2234 Tentative de connexion échouée.
CPF1107 Mot de passe incorrect.
CPF1393 Accès refusé.

Remarque :
Vous pouvez ajouter des filtres (plage horaire, autres messages de refus , etc …)
Vous devrez découper vous même la zone entry data, vous pouvez également utiliser les fonctions table QSYS2.DISPLAY_JOURNALxx spécialisées par TYPE

Plus d’information ici https://www.ibm.com/support/pages/qsys2displayjournal