Articles

, , CCSID des fichiers sources

Retour sur une problématique récurrente et souvent mal comprise, donc mal gérée … Et qui pourrait bien s’amplifier avec l’usage plus intensif de l’Open Source.

Vous utilisez historiquement des fichiers sources (objet *FILE attribut PF-SRC) pour stocker vos sources : ces fichiers sont créés avec un CCSID, par défaut le CCSID du job dans lequel vous exécutez la commande CRTSRCPF

Usuellement vous obtiendrez des fichiers sources avec un CCSID 297 ou 1147 pour la France. Si vos machines sont « incorrectement » réglées, un CCSID 65535 (hexadécimal).

Mais également, par restauration d’autres produits, certainement des fichiers avec un CCSID 37 (US).

Pour les langages de programmation (dont le SQL), le CCSID du fichier source est important pour les constantes, qui peuvent par définition êtres des caractères nationaux quelconques. Quant aux instructions, la grammaire des langages les définis sans ambiguïtés.

Caractères spéciaux / nationaux

Pour toutes les commandes, instructions, éléments du langage, pas de soucis d’interprétation

A la compilation, les constantes sont interprétées suivant le CCSID du job, pas celui du source !

En général, les deux CCSID sont identiques.

Par contre, pour les caractères spéciaux utilisés, si l’on regarde de plus près le cas du CL, la documentation indique :

Voilà qui explique les fameuses transformations de @ en à !

En synthèse : le compilateur considère tous les éléments du langage comme étant en CCSID 37, hors les constantes alphanumériques et les quelques caractères listés ici.

Pour le CL : impossible d’utiliser les opérateurs symboliques |> (*BCAT), |< (*TCAT) et || (*CAT)

Le caractère | est mal interprété. Vous devez le remplacer par un !, ou utiliser les opérateurs non symboliques (*BCAT, *TCAT et *CAT).

Pour le SQL : impossible d’utiliser l’opérateur || (même raison).

Vous devez le remplacer par un !!, ou utiliser l’opérateur concat.

Evolution du RPG

Le principe est le même.

Toutefois le langage vous permet également de contrôler le CCSID des variables déclarées. Et depuis la 7.2, de nouvelles directives de pré-compilation permettent d’indiquer des valeurs de CCSID par défaut par bloc de source :

Et pour l’IFS ?

Sur l’IFS, chaque fichier (source ou non) dispose également d’un CCSID. Sa valeur dépend principalement de la façon de créer le fichier (par un éditeur type RDi/VSCode, partage netserver, transfert FTP …).

Premier point d’attention : l’encodage du contenu du fichier doit correspondre à son attribut *CCSID !

VSCode vous indique le CCSID de la donnée, par exemple :

Mais :

1252 = Windows occidental (proche de l’UTF-8 mais pas identique). La raison est que VSCode travaille naturellement en UTF-8.

RDi gère correctement l’encodage/décodage par rapport à la description du fichier.

Pour les autres outils, à voir au cas par cas !

Evolution des compilateurs

Les compilateurs C, CPP, CL, RPG, COBOL supportent désormais (PTF en fonction des compilateurs) un paramètre TGTCCSID :

En réalité ce paramètre a été ajouté pour permettre la compilation plus facilement depuis l’IFS, principalement depuis des fichiers IFS en UTF-8.

Cela ne règle pas nos problèmes précédents, les éléments du langage n’étant pas concernés : nous auront toujours le problème d’interprétation du |

Par contre, c’est utile pour la bonne interprétation des constantes lorsque le job de compilation a un CCSID du source. Et cela permet une meilleure intégration dans les outils d’automatisation.

Conseils

Eviter les caractères spéciaux !

  • N’utilisez pas |>, |< ou || en CL
  • N’utilisez pas || en SQL

Mais on ne peut pas toujours : nous avons voulu compiler QSHONI depuis le build fourni (https://github.com/richardschoen/QshOni?tab=readme-ov-file#installing-and-building-qshoni-via-git-clone-and-buildsh)

Le script propose d’indiquer un CCSID pour les fichiers sources. Mais la seule solution viable est de compiler avec un job en CCSID 37 :

  • soit CHGJOB CCSID(37) avant de lancer le script
  • soit vous pouvez vous créer un profil dédié en CCSID 37 si ces opérations sont récurrentes

Tant que vous n’avez pas de caractères nationaux dans le codes !

Retrouver le CCSID de ses fichiers sources

SELECT f.SYSTEM_TABLE_NAME,
       f.SYSTEM_TABLE_SCHEMA,
       c."CCSID"
    FROM qsys2.systables f
         JOIN qsys2.syscolumns c
             ON (c.SYSTEM_TABLE_NAME, c.SYSTEM_TABLE_SCHEMA) = (f.SYSTEM_TABLE_NAME, f.SYSTEM_TABLE_SCHEMA)
    WHERE f.file_type = 'S' AND
LEFT(f.system_table_name, 8) <> 'EVFTEMPF' AND
          c.SYSTEM_COLUMN_NAME = 'SRCDTA'
    ORDER BY c."CCSID",
             f.SYSTEM_TABLE_SCHEMA,
             f.SYSTEM_TABLE_NAME;

Références

https://www.ibm.com/support/pages/ifs-stmf-ccsids-1252-437-and-819

https://www.ibm.com/docs/en/i/7.4?topic=languages-language-compilers-ccsid

https://www.ibm.com/mysupport/s/fix-information/aDrKe000000PE0UKAW/fi0132711?language=en_US

https://www.ibm.com/mysupport/s/defect/aCIKe000000XohkOAC/dt418562?language=en_US

https://www.ibm.com/docs/en/i/7.5?topic=elements-cl-character-sets-values

https://www.ibm.com/docs/en/i/7.5?topic=values-symbolic-operators

https://www.ibm.com/docs/fr/i/7.5?topic=languages-language-compilers-ccsid

https://www.ibm.com/support/pages/have-you-heard-set-and-restore-directives

https://github.com/richardschoen/QshOni

, CONTROLER IBAN & RIB

L’International Bank Account Number, généralement nommé sous l’acronyme IBAN, est un système international de numérotationLe numéro IBAN, ou code IBAN, est affiché sur votre Relevé d’Identité Bancaire (RIB). Formalisé par une suite de chiffres et de lettres pas toujours compréhensibles pour les usagers bancaires, l’IBAN est une norme internationale ISO qui a été mise en place pour sécuriser et faciliter les échanges et transferts bancaires internationaux sur tous les continents.

Dans cet article nous allons voir comment vérifier si la clé d’un IBAN est correcte. Ensuite nous effectuerons la vérification de la clé d’un RIB. Les exemples sont basés sur un compte bancaire français.

Contrôler la clé IBAN

Structure de l’IBAN

FRKK BBBB BGGG GGCC CCCC CCCC CKK

B = code banque
G = code guichet
C = numéro de compte
K = clef

Le RIB (ou BBAN) comprend les informations suivantes :

– Le nom de la banque et de l’agence;
– Le code banque à 5 chiffres;
– Le code guichet à 5 chiffres ;
– Le numéro du compte à 11 chiffres ou lettres au maximum;
– La clé RIB, à 2 chiffres.

Le calcul de la clé IBAN est fonction de l’enchaînement entre le BBAN, le code pays (transformé en données chiffrées) et 00.
Concernant la conversion du code pays, il faut savoir que la lettre A équivaut au nombre 10, B = 11, C = 12, D = 13… jusqu’à la dernière lettre de l’alphabet Z qui vaut 35.


La formule arithmétique pour résoudre l’équation et déterminer une clé IBAN est :

Clé IBAN = 98 – ((Valeur numérique) modulo 97).

Il faut donc procéder en deux étapes :

  • Reconstituer l’IBAN sous la forme BBAN + [Code Pays ISO2] + « 00 »
  • Remplacer toutes les lettres de l’IBAN par le nombre qui leur correspond (entre 10 et 35)

Voici une procédure, écrite dans un programme de service, qui permet la vérification de la clé d’un IBAN.

dcl-proc checkIban export;
  dcl-pi *n ind;
    numIban char(27) const;
  end-pi;

  dcl-s count int(3) ;
  dcl-s index int(3) ;
  dcl-s posit int(3) ;
  dcl-s stringToCalculate varchar(50) ;
  dcl-c letters    'ABCDEFGHIJKLMNOPQRSTUVWXYZ' ;

  stringToCalculate = %subst(numIban:5) + %subst(numIban:1:2) + '00';

  for count = 1 to %len(%trim(stringToCalculate)) ;
    index = %scan(%subst(stringToCalculate:count:1):letters) ;
    if index > 0 ;
      posit = count - 1 ;
      index += 9 ;
    
      stringToCalculate = %subst(stringToCalculate : 1 : posit)
                        + %trim(%char(index))
                        + %subst(stringToCalculate : posit + 2) ;
    endif ;
  endfor;

  return (98 - %rem(%DEC(%trim(stringToCalculate) : 50 : 0):97)
         = %DEC(%SUBST(numIban : 3 : 2) : 2 : 0)) ;

end-proc;                       

Ajouter le code suivant dans le source de liage

EXPORT     SYMBOL("CHECKIBAN") 

Utilisation du contrôle

// Déclaration
dcl-PR checkIban ind ;
 P_Iban char(27) const;
end-pr ;         

// Appel
 retour = checkIban('FR3330002005500000157841Z25');
  if retour;
    dsply 'IBAN Correct' ;
  else ;
    dsply 'IBAN Faux' ;
  endif;  

Contrôler la clé RIB

Structure du RIB (voir paragraphe précédent, c’est un composant de l’IBAN)

Le numéro de RIB permet l’identification du compte pour une utilisation Nationale. C’est le numéro à transmettre pour effectuer un virement en France.

La clé RIB est une formule mathématique, qui ne peut s’appliquer que sur des valeurs numériques. Il convient donc de remplacer les éventuelles lettres présentes dans les données du RIB avant de pouvoir en calculer la clé.

Chaque lettre est remplacée par son équivalent numérique :

A,J = 1

B,K,S = 2

C,L,T = 3

D,M,U = 4

E,N,V = 5

F,O,W = 6

G,P,X = 7

H,Q,Y = 8

I,R,Z = 9

La clé peut alors être calculée avec la formule suivante :

Clé RIB = 97 – ( ( 89 x Code banque + 15 x Code guichet + 3 x Numéro de compte ) modulo 97 )

Voici une procédure, écrite dans un programme de service, qui permet la vérification de la clé d’un RIB.

dcl-proc checkRib export;
  dcl-pi *n ind;
    numRib char(23) const ;
  end-pi;

  dcl-s count int(3) ;
  dcl-s index int(3) ;
  dcl-s posit int(3) ;
  dcl-s stringToCalculate varchar(23) ;
  dcl-c letters    'ABCDEFGHIJKLMNOPQRSTUVWXYZ' ;

  stringToCalculate = numRib ;

  for count = 1 to %len(%trim(stringToCalculate)) ;
    index = %scan(%subst(stringToCalculate:count:1) : letters) ;
    if index > 0;
      posit = count - 1 ;
      select ;
        when index >= 10 and index <= 18 ;
          index -= 9 ;
        when index >= 19 ;
          index -= 17 ;
      endsl ;

      stringToCalculate = %subst(stringToCalculate : 1 : posit)
                        + %trim(%char(index))
                        + %subst(stringToCalculate : posit + 2) ;
    endif ;
  endfor ;

  return (97 - %rem(
                  (%DEC(%subst(stringToCalculate:1:5) : 5 : 0)*89
                  + %DEC(%subst(stringToCalculate:6:5) : 5 : 0)*15
                  + %DEC(%subst(stringToCalculate:11:11) : 11 : 0)*3)
                    :97)
          = %DEC(%SUBST(stringToCalculate : 22 : 2) : 2 : 0)) ;

end-proc;  

Ajouter le code suivant dans le source de liage

EXPORT     SYMBOL("CHECKRIB") 

Utilisation du contrôle

// Déclaration
dcl-PR checkRib ind ;
 P_Rib char(23) const ;
end-pr ;               

// Appel
retour = checkRib('3000200550044AB57O41Z68') ;
  if retour;
    dsply 'RIB Correct'  ;
  else ;
    dsply 'RIB Faux' ;
  endif;